local 装备处理类 = class()
local floor = math.floor
local random = 取随机数
local remove = table.remove
local 附加范围 = {
	"力量",
	"敏捷",
	"体质",
	"耐力",
	"魔力"
}
local 附加上限 = {
	[60] = {
		27,
		22
	},
	[80] = {
		30,
		25
	},
	[90] = {
		33,
		28
	},
	[100] = {
		36,
		31
	},
	[110] = {
		39,
		34
	},
	[120] = {
		42,
		37
	},
	[130] = {
		45,
		40
	},
	[140] = {
		48,
		43
	},
	[150] = {
		51,
		46
	},
	[160] = {
		54,
		49
	}
}

function 装备处理类:初始化()
	self.打造物品 = 绑定等级物品()
end

function 装备处理类:通灵重置丹处理(id, 装备编号, 道具编号, 装备数据, 道具数据, 全部道具, 装备格子, 道具格子)
	if 装备数据.附带技能 == nil or 装备数据.附带技能 == {} then
		常规提示(id, "这件通灵装备无法重置技能。")

		return
	end

	if string.find(道具数据.名称, "通灵重置丹") and 通灵装备1[装备数据.名称] ~= nil then
		if 装备数据.等级 == nil then
			装备数据.等级 = 取护符等级(装备数据.名称)
		end

		if 道具数据.等级 == nil then
			道具数据.等级 = 取护符等级(道具数据.名称)
		end

		if 装备数据.等级 <= 道具数据.等级 then
			if 全部道具[道具编号] ~= nil and 全部道具[道具编号].数量 >= 1 then
				全部道具[道具编号].数量 = 全部道具[道具编号].数量 - 1

				if 全部道具[道具编号].数量 < 1 then
					全部道具[道具编号] = nil
				end
			else
				常规提示(id, "#Y/重置丹数量不足。")

				return
			end

			local 技能数量 = #装备数据.附带技能
			local 临时技能 = nil
			local pd = 1

			while 装备数据.附带技能 == 临时技能 or pd == 1 do
				if 洗通灵装备模式 == 1 then
					if 技能数量 > 1 then
						临时技能 = 取护符技能(装备数据.名称, 技能数量)
					else
						临时技能 = 取护符技能(装备数据.名称)
					end
				elseif 洗通灵装备模式 == 2 then
					临时技能 = 取护符技能(装备数据.名称, 2)
				else
					临时技能 = 取护符技能(装备数据.名称, 技能数量)
				end

				pd = 0
			end

			发送数据(玩家数据[id].连接id, 64.1, {
				装备编号 = 装备编号,
				装备数据 = 装备数据,
				临时技能 = 临时技能
			})
			刷新道具行囊单格(id, "道具", 道具格子, 道具编号)
			发送数据(玩家数据[id].连接id, 64.3)
		else
			常规提示(id, "#Y/失败,该重置丹无法对这个级别的通灵装备使用。")

			return
		end
	else
		常规提示(id, "#Y/道具属性出错2,使用失败。")

		return
	end
end

function 装备处理类:通灵重置丹确认(id, 装备编号, 装备数据, 临时技能, 临时文本, 全部道具, 装备格子)
	装备数据.附带技能 = 临时技能

	常规提示(id, "通灵装备重置技能成功。#R【" .. 临时文本 .. "】")
	刷新道具行囊单格(id, "道具", 装备格子, 装备编号)
	发送数据(玩家数据[id].连接id, 64.3)
end

function 装备处理类:转换符确认(id, 装备编号, 装备数据, 临时文本, 临时文本1, 全部道具, 装备格子)
	local 五维 = {
		"魔力",
		"力量",
		"体质",
		"耐力",
		"敏捷"
	}

	if 装备数据.分类 == 6 then
		五维 = {
			"魔力",
			"力量",
			"体质",
			"耐力"
		}
	end

	for i = 1, #五维 do
		装备数据[五维[i]] = nil
	end

	for i = 1, #临时文本 do
		装备数据[临时文本[i][1]] = 临时文本[i][2]
	end

	常规提示(id, "转换装备属性成功。#R【" .. 临时文本1 .. "】")
	刷新道具行囊单格(id, "道具", 装备格子, 装备编号)
	玩家数据[id].角色:刷新信息()
	发送数据(玩家数据[id].连接id, 64.3)
end

function 装备处理类:转换符处理(id, 装备编号, 道具编号, 装备数据, 道具数据, 全部道具, 装备格子, 道具格子)
	if 道具数据.名称 == "属性转换符" then
		if 全部道具[道具编号] ~= nil and 全部道具[道具编号].数量 >= 1 then
			全部道具[道具编号].数量 = 全部道具[道具编号].数量 - 1

			if 全部道具[道具编号].数量 < 1 then
				全部道具[道具编号] = nil
			end
		else
			常规提示(id, "#Y/转换符数量不足。")

			return
		end

		local 五维 = {
			"魔力",
			"力量",
			"体质",
			"耐力",
			"敏捷"
		}

		if 装备数据.分类 == 6 then
			五维 = {
				"魔力",
				"力量",
				"体质",
				"耐力"
			}
		end

		local ww1 = {}
		local ww2 = {}
		local ww3 = {}

		for i = 1, #五维 do
			if 装备数据[五维[i]] ~= nil then
				ww1[#ww1 + 1] = 五维[i]
				ww2[#ww2 + 1] = 装备数据[五维[i]] + 0
			end
		end

		for i = 1, #ww1 do
			local wz = 取随机数(1, #五维)
			ww3[i] = 五维[wz]

			if #五维 == 1 and ww3[i] == ww1[i] and i == #ww1 then
				local wz1 = 取随机数(1, i - 1)
				ww3[i] = ww3[wz1]
				ww3[wz1] = 五维[wz]
			else
				while ww3[i] == ww1[i] do
					wz = 取随机数(1, #五维)
					ww3[i] = 五维[wz]
				end

				table.remove(五维, wz)
			end
		end

		local 临时文本 = {}

		for i = 1, #ww3 do
			临时文本[#临时文本 + 1] = {
				ww3[i],
				ww2[i]
			}
		end

		发送数据(玩家数据[id].连接id, 64.2, {
			装备编号 = 装备编号,
			装备数据 = 装备数据,
			临时文本 = 临时文本
		})
		刷新道具行囊单格(id, "道具", 道具格子, 道具编号)
		发送数据(玩家数据[id].连接id, 64.3)
	else
		常规提示(id, "#Y/道具属性出错3,使用失败。")

		return
	end
end

function 装备处理类:吸附兽决处理(id, 装备编号, 道具编号, 装备数据, 道具数据, 全部道具, 装备格子, 道具格子)
	local 临时五行 = {}
	local 更改 = false

	if 装备数据.附带技能 == nil then
		常规提示(id, "这个兽决没有技能。")

		return
	end

	if 道具数据.名称 == "吸附石" then
		local 吸附技能 = 装备数据.附带技能
		全部道具[道具编号].数量 = 全部道具[道具编号].数量 - 1
		全部道具[装备编号].数量 = (全部道具[装备编号].数量 or 1) - 1

		if 全部道具[道具编号].数量 < 1 then
			全部道具[道具编号] = nil
		end

		if 全部道具[装备编号].数量 < 1 then
			全部道具[装备编号] = nil
		end

		if 取随机数(1, 10000) <= 吸附兽决几率 * 100 then
			玩家数据[id].道具:给予道具(id, "点化石", 1, 吸附技能)
			常规提示(id, "吸附成功！恭喜你获得了一个#R" .. 吸附技能 .. "#Y点化石")
		else
			常规提示(id, "很遗憾，吸附失败。")
		end

		刷新道具行囊单格(id, "道具", 道具格子, 道具编号)
		刷新道具行囊单格(id, "道具", 装备格子, 装备编号)
		发送数据(玩家数据[id].连接id, 64.3)
	else
		常规提示(id, "#Y/道具属性出错4,使用失败。")

		return
	end
end

function 装备处理类:灵饰洗练处理(id, 装备编号, 道具编号, 装备数据, 道具数据, 全部道具, 装备格子, 道具格子)
	if 道具数据.名称 == "灵饰洗练石" then
		if 装备数据.灵饰 == true and 装备数据.幻化属性 ~= nil and 装备数据.幻化属性.附加 ~= nil and #装备数据.幻化属性.附加 > 0 and 全部道具[道具编号] ~= nil then
			全部道具[道具编号].数量 = (全部道具[道具编号].数量 or 1) - 1

			if 全部道具[道具编号].数量 < 1 then
				全部道具[道具编号] = nil
			end

			local aa = {
				[12.0] = "戒指",
				[10.0] = "耳饰",
				[13.0] = "手镯",
				[11.0] = "佩饰"
			}
			local 灵饰附加属性 = 装备数据.幻化属性.附加
			local 等级 = 装备数据.级别限制
			local 强化等级 = 装备数据.幻化等级 or 0
			local 种类 = aa[装备数据.分类]
			local 副属性列表 = 灵饰属性[种类].副属性

			for i = 1, #灵饰附加属性 do
				local 新副属性 = 副属性列表[ygsj(#副属性列表)]
				灵饰附加属性[i] = {
					类型 = 新副属性,
					数值 = 取随机数(灵饰属性.基础[新副属性][等级].a, 灵饰属性.基础[新副属性][等级].b),
					强化 = 幻化属性强化[新副属性] * 强化等级
				}
			end

			常规提示(id, "灵饰洗练成功！")
			刷新道具行囊单格(id, "道具", 道具格子, 道具编号)
			刷新道具行囊单格(id, "道具", 装备格子, 装备编号)
			发送数据(玩家数据[id].连接id, 64.3)
		else
			print(tostring(装备数据.灵饰) .. tostring(全部道具[道具编号]) .. tostring(装备数据.幻化属性) .. tostring(#装备数据.幻化属性.附加))
			常规提示(id, "#Y/装备属性出错,使用失败。")

			return
		end
	else
		常规提示(id, "#Y/道具属性出错5,使用失败。")

		return
	end
end

function 装备处理类:五行石处理(id, 装备编号, 道具编号, 装备数据, 道具数据, 全部道具, 装备格子, 道具格子)
	local 临时五行 = {}
	local 更改 = false

	if 五行石模式 == 0 and (装备数据.超级五行 == nil or 装备数据.超级五行.类型 == nil) then
		常规提示(id, "这件装备没有超级五行，无法更换。")

		return
	end

	if 道具数据.名称 == "五行石" then
		if 装备数据.超级五行 ~= nil and 装备数据.超级五行.类型 ~= nil then
			临时五行 = 取超级五行处理(装备数据.级别限制, 100)

			while 临时五行.类型 == 装备数据.超级五行.类型 do
				临时五行 = 取超级五行处理(装备数据.级别限制, 100)
			end

			更改 = true
		else
			临时五行 = 取超级五行处理(装备数据.级别限制, 100)
		end

		全部道具[道具编号].数量 = 全部道具[道具编号].数量 - 1

		if 全部道具[道具编号].数量 < 1 then
			全部道具[道具编号] = nil
		end

		if 取随机数(1, 10000) <= 五行石成功几率 or (装备数据.五行石次数 or 0) >= 五行石保底次数 - 1 or 更改 == true then
			装备数据.超级五行 = 临时五行
			装备数据.五行 = 临时五行.类型

			if (装备数据.五行石次数 or 0) >= 五行石保底次数 - 1 then
				常规提示(id, "#R(触发了保底)#Y恭喜你，赋予装备#R超级五行(" .. 临时五行.类型 .. ")#W成功。")
			elseif 更改 == true then
				常规提示(id, "恭喜你，装备超级五行更改为：#R超级五行(" .. 临时五行.类型 .. ")#W。")
			else
				常规提示(id, "恭喜你，赋予装备#R超级五行(" .. 临时五行.类型 .. ")#W成功。")
			end

			装备数据.五行石次数 = nil
		else
			常规提示(id, "很遗憾，赋予失败。")

			装备数据.五行石次数 = (装备数据.五行石次数 or 0) + 1
		end

		刷新道具行囊单格(id, "道具", 道具格子, 道具编号)
		刷新道具行囊单格(id, "道具", 装备格子, 装备编号)
		发送数据(玩家数据[id].连接id, 64.3)
	else
		常规提示(id, "#Y/道具属性出错6,使用失败。")

		return
	end
end

function 装备处理类:七彩石处理(id, 装备编号, 道具编号, 装备数据, 道具数据, 全部道具, 装备格子, 道具格子)
	local 临时特殊 = {}

	if 道具数据.名称 == "七彩石" then
		local 道具等级 = 装备数据.级别限制
		local 临时属性, 临时数值 = nil
		local 主属性 = {
			"命中",
			"气血",
			"灵力",
			"魔法",
			"速度",
			"防御",
			"伤害"
		}
		local 副属性 = {
			"抗封印等级",
			"法伤",
			"法术伤害结果",
			"法术暴击等级",
			"抗法术暴击等级",
			"治疗能力",
			"抗物理暴击等级",
			"格挡值",
			"气血回复效果",
			"封印命中等级",
			"固定伤害",
			"狂暴等级",
			"穿刺等级",
			"物理暴击等级"
		}

		if math.random(100) > 50 then
			临时属性 = 主属性[math.random(1, #主属性)]
			临时数值 = math.random(math.floor(道具等级 * 0.3), math.floor(道具等级 * 0.5))

			if 临时属性 == "灵力" then
				临时数值 = math.ceil(临时数值 / 1.5)
			elseif 临时属性 == "气血" or 临时属性 == "魔法" then
				临时数值 = 临时数值 * 4
			end
		else
			临时属性 = 副属性[math.random(1, #副属性)]
			临时数值 = math.random(math.floor(道具等级 * 0.1), math.floor(道具等级 * 0.3))
		end

		临时特殊 = {
			类型 = 临时属性,
			数值 = 临时数值
		}
		全部道具[道具编号].数量 = 全部道具[道具编号].数量 - 1

		if 全部道具[道具编号].数量 < 1 then
			全部道具[道具编号] = nil
		end

		if 取随机数(1, 10000) <= 七彩石成功几率 or (装备数据.七彩石次数 or 0) >= 七彩石保底次数 - 1 then
			装备数据.特殊附加属性 = 临时特殊

			if (装备数据.七彩石次数 or 0) >= 七彩石保底次数 - 1 then
				常规提示(id, "#R(触发了保底)#Y恭喜你，赋予装备特殊属性成功。【" .. 临时属性 .. "+" .. 临时数值 .. "】")
			else
				常规提示(id, "恭喜你，赋予装备特殊属性成功。【" .. 临时属性 .. "+" .. 临时数值 .. "】")
			end

			装备数据.七彩石次数 = nil
		else
			常规提示(id, "很遗憾，赋予失败。")

			装备数据.七彩石次数 = (装备数据.七彩石次数 or 0) + 1
		end

		刷新道具行囊单格(id, "道具", 道具格子, 道具编号)
		刷新道具行囊单格(id, "道具", 装备格子, 装备编号)
		发送数据(玩家数据[id].连接id, 64.3)
	else
		常规提示(id, "#Y/道具属性出错7,使用失败。")

		return
	end
end

function 装备处理类:特技石处理(id, 装备编号, 道具编号, 装备数据, 道具数据, 全部道具, 装备格子, 道具格子)
	local 临时装备 = {}

	if 道具数据.名称 == "特技石" and 道具数据.特效 ~= nil then
		if 装备数据.分类 > 6 then
			常规提示(id, "#R" .. 道具数据.特效 .. "#Y/特技不能赋予给灵饰或召唤兽装备。")

			return
		end

		装备数据.特技 = 道具数据.特效
		全部道具[道具编号].数量 = 全部道具[道具编号].数量 - 1

		if 全部道具[道具编号].数量 < 1 then
			全部道具[道具编号] = nil
		end

		常规提示(id, "恭喜你，赋予装备特效成功。")
		刷新道具行囊单格(id, "道具", 道具格子, 道具编号)
		刷新道具行囊单格(id, "道具", 装备格子, 装备编号)
		发送数据(玩家数据[id].连接id, 64.3)
	else
		常规提示(id, "#Y/道具属性出错8,使用失败。")

		return
	end
end

function 装备处理类:特效石处理(id, 装备编号, 道具编号, 装备数据, 道具数据, 全部道具, 装备格子, 道具格子)
	local 道具使用 = false
	local 临时装备 = {}

	if 道具数据.名称 == "特效石" and 道具数据.特效 ~= nil then
		local 特效判断 = {}
		local 新特效判断 = {}
		local 特效数 = 0

		if 装备数据.特效 ~= nil then
			特效数 = 特效数 + #装备数据.特效
			特效判断 = 列表模式转换(装备数据.特效)
		end

		if 装备数据.新特效 ~= nil and type(装备数据.新特效) == "table" then
			特效数 = 特效数 + #装备数据.新特效
			新特效判断 = 列表模式转换(装备数据.新特效)

			if 新特效判断.祝福 ~= nil then
				特效数 = 特效数 - 1
			end
		end

		if 打造最大特效数量 <= 特效数 then
			常规提示(id, "#Y该装备拥有的#R特效数量#Y已经达到上限。")

			return
		end

		if 通用新特效1[道具数据.特效] ~= nil then
			if 装备数据.分类 == 7 or 装备数据.分类 == 8 or 装备数据.分类 == 9 or 装备数据.灵饰 == true then
				常规提示(id, "#R" .. 道具数据.特效 .. "#Y/特效不能赋予给灵饰或召唤兽装备。")

				return
			elseif 新特效判断[道具数据.特效] ~= nil then
				常规提示(id, "#Y/你的这件装备已经有#R" .. 道具数据.特效 .. "#Y特效,无需赋予。")

				return
			end

			临时装备.新特效 = 道具数据.特效
			道具使用 = true
		elseif 通用特效1[道具数据.特效] ~= nil then
			if (装备数据.分类 == 7 or 装备数据.分类 == 8 or 装备数据.分类 == 9 or 装备数据.灵饰 == true) and 道具数据.特效 ~= "无级别限制" and 道具数据.特效 ~= "超级简易" and 道具数据.特效 ~= "简易" and 道具数据.特效 ~= "永不磨损" then
				常规提示(id, "#R" .. 道具数据.特效 .. "#Y/特效不能赋予给灵饰或召唤兽装备。")

				return
			end

			if 特效判断[道具数据.特效] ~= nil then
				常规提示(id, "#Y/你的这件装备已经有#R" .. 道具数据.特效 .. "#Y特效,无需赋予。")

				return
			end

			临时装备.特效 = 道具数据.特效
			道具使用 = true
		end

		if 道具使用 == true then
			全部道具[道具编号].数量 = (全部道具[道具编号].数量 or 1) - 1

			if 全部道具[道具编号].数量 < 1 then
				全部道具[道具编号] = nil
			end

			if 取随机数(1, 10000) <= 特效石成功几率 or (装备数据.特效石次数 or 0) >= 特效石保底次数 - 1 then
				if 临时装备.新特效 ~= nil then
					if 装备数据.新特效 == nil then
						装备数据.新特效 = {
							临时装备.新特效
						}
					else
						装备数据.新特效[#装备数据.新特效 + 1] = 临时装备.新特效
					end
				elseif 临时装备.特效 ~= nil then
					if 装备数据.特效 == nil then
						装备数据.特效 = {
							临时装备.特效
						}
					else
						装备数据.特效[#装备数据.特效 + 1] = 临时装备.特效
					end

					特效判断[临时装备.特效] = 1
				end

				if (装备数据.特效石次数 or 0) >= 特效石保底次数 - 1 then
					常规提示(id, "#R(触发了保底)#Y恭喜你，赋予装备特效成功。")
				else
					常规提示(id, "恭喜你，赋予装备特效成功。")
				end

				装备数据.特效石次数 = nil

				取装备实际等级(装备数据, 特效判断)
			else
				常规提示(id, "很遗憾，赋予失败。")

				装备数据.特效石次数 = (装备数据.特效石次数 or 0) + 1
			end

			刷新道具行囊单格(id, "道具", 道具格子, 道具编号)
			刷新道具行囊单格(id, "道具", 装备格子, 装备编号)
			发送数据(玩家数据[id].连接id, 64.3)
		end
	else
		常规提示(id, "#Y/道具属性出错1,使用失败。")

		return
	end
end

取装备实际等级 = function(装备数据, 特效判断)
	if 特效判断.无级别限制 ~= nil then
		装备数据.实际等级 = "0#G(" .. 装备数据.级别限制 .. "-" .. 装备数据.级别限制 .. ")"
	elseif 特效判断.超级简易 ~= nil then
		装备数据.实际等级 = tostring(math.max(tonumber(装备数据.级别限制) - 超级简易等级数, 0)) .. "#G(" .. 装备数据.级别限制 .. "-" .. 超级简易等级数 .. ")"
	elseif 特效判断.简易 ~= nil then
		装备数据.实际等级 = tostring(math.max(tonumber(装备数据.级别限制) - 简易等级数, 0)) .. "#G(" .. 装备数据.级别限制 .. "-" .. 简易等级数 .. ")"
	end
end

制作打造符 = function(id, n, 名称)
	local 对话 = "请选择你要制作的#R" .. 名称 .. "#W等级。"
	local 选项 = {}
	local dj = math.floor(玩家数据[id].角色.数据.辅助技能[n].等级 / 10)

	while dj >= 5 do
		选项[#选项 + 1] = "1张" .. tostring(dj * 10) .. "级" .. 名称
		选项[#选项 + 1] = "2张" .. tostring(dj * 10) .. "级" .. 名称
		选项[#选项 + 1] = "3张" .. tostring(dj * 10) .. "级" .. 名称
		选项[#选项 + 1] = "4张" .. tostring(dj * 10) .. "级" .. 名称
		选项[#选项 + 1] = "5张" .. tostring(dj * 10) .. "级" .. 名称
		dj = dj - 1
	end

	发送数据(玩家数据[id].连接id, 1501, {
		名称 = "制作" .. 名称,
		模型 = 玩家数据[id].角色.数据.模型,
		对话 = 对话,
		选项 = 选项
	})
end

function 装备处理类:数据处理(连接id, 序号, id, 内容)
	if 序号 == 4501 then
		if 玩家数据[id].打造方式 == 2 and 玩家数据[id].角色:取任务(5) ~= 0 then
			常规提示(id, "#Y/你已经有一个打造任务在进行了")

			return
		elseif 玩家数据[id].打造方式 == nil then
			return
		end

		self:打造类型处理(连接id, 序号, id, 内容)
	elseif 序号 == 4502 then
		self:装备开运(连接id, 序号, id, 内容)
	elseif 序号 == 4502.1 then
		self:装备开启星位(连接id, 序号, id, 内容)
	elseif 序号 == 4503 then
		self:宝石镶嵌处理(连接id, 序号, id, 内容)
	elseif 序号 == 4504 then
		self:宝石合成处理(连接id, 序号, id, 内容)
	elseif 序号 == 4505 then
		self:装备修理处理(连接id, 序号, id, 内容)
	elseif 序号 == 4506 then
		self:装备熔炼处理(连接id, 序号, id, 内容)
	elseif 序号 == 4507.1 then
		local n = 角色辅助技能列表1.打造技巧

		if 玩家数据[id].角色.数据.辅助技能[n].等级 >= 50 then
			制作打造符(id, n, "打造符")
		else
			常规提示(id, "#Y/你的【#R打造技巧#Y】小于50级，无法制作打造符。")

			return
		end
	elseif 序号 == 4507.2 then
		local n = 角色辅助技能列表1.裁缝技巧

		if 玩家数据[id].角色.数据.辅助技能[n].等级 >= 50 then
			制作打造符(id, n, "裁缝符")
		else
			常规提示(id, "#Y/你的【#R裁缝技巧#Y】小于50级，无法制作打造符。")

			return
		end
	elseif 序号 == 4507.3 then
		local n = 角色辅助技能列表1.炼金术

		if 玩家数据[id].角色.数据.辅助技能[n].等级 >= 50 then
			制作打造符(id, n, "炼金符")
		else
			常规提示(id, "#Y/你的【#R炼金术#Y】小于50级，无法制作打造符。")

			return
		end
	elseif 序号 == 4507 then
		if 玩家数据[id].角色.数据.道具行囊打开.道具 ~= nil then
			发送数据(玩家数据[id].连接id, 14)
		else
			发送数据(玩家数据[id].连接id, 14, 玩家数据[id].道具:索要道具1(id))
		end

		玩家数据[id].打造方式 = 1
	elseif 序号 == 4508 then
		if 定制装备融合 then
			self:装备熔合处理(连接id, 序号, id, 内容)
		else
			发送数据(玩家数据[id].连接id, 7, "#Y该功能尚未开放！")
		end
	elseif 序号 == 4510.13 then
		local 装备编号 = 玩家数据[id].角色.数据.道具[内容.装备编号]
		local 道具编号 = 玩家数据[id].角色.数据.道具[内容.道具编号]
		local 装备数据 = 玩家数据[id].道具.数据[装备编号]
		local 道具数据 = 玩家数据[id].道具.数据[道具编号]

		self:灵饰洗练处理(id, 装备编号, 道具编号, 装备数据, 道具数据, 玩家数据[id].道具.数据, 内容.装备编号, 内容.道具编号)
	elseif 序号 == 4510.11 then
		local 装备编号 = 玩家数据[id].角色.数据.道具[内容.装备编号]
		local 道具编号 = 玩家数据[id].角色.数据.道具[内容.道具编号]
		local 装备数据 = 玩家数据[id].道具.数据[装备编号]
		local 道具数据 = 玩家数据[id].道具.数据[道具编号]

		self:吸附兽决处理(id, 装备编号, 道具编号, 装备数据, 道具数据, 玩家数据[id].道具.数据, 内容.装备编号, 内容.道具编号)
	elseif 序号 == 4510.9 then
		local 装备数据 = 玩家数据[id].道具.数据[内容.装备编号]

		self:转换符确认(id, 内容.装备编号, 装备数据, 内容.临时文本, 内容.临时文本1, 玩家数据[id].道具.数据, 内容.道具编号)
	elseif 序号 == 4510.8 then
		local 装备编号 = 玩家数据[id].角色.数据.道具[内容.装备编号]
		local 道具编号 = 玩家数据[id].角色.数据.道具[内容.道具编号]
		local 装备数据 = 玩家数据[id].道具.数据[装备编号]
		local 道具数据 = 玩家数据[id].道具.数据[道具编号]

		self:转换符处理(id, 装备编号, 道具编号, 装备数据, 道具数据, 玩家数据[id].道具.数据, 内容.装备编号, 内容.道具编号)
	elseif 序号 == 4510.7 then
		玩家数据[id].道具:一键出售道具1(id, id, true, 内容.装备编号)
		发送数据(玩家数据[id].连接id, 64.3, 玩家数据[id].道具:索要道具1(id))
	elseif 序号 == 4510.6 then
		local 装备数据 = 玩家数据[id].道具.数据[内容.装备编号]

		self:通灵重置丹确认(id, 内容.装备编号, 装备数据, 内容.临时技能, 内容.临时文本, 玩家数据[id].道具.数据, 内容.装备编号)
	elseif 序号 == 4510.5 then
		local 装备编号 = 玩家数据[id].角色.数据.道具[内容.装备编号]
		local 道具编号 = 玩家数据[id].角色.数据.道具[内容.道具编号]
		local 装备数据 = 玩家数据[id].道具.数据[装备编号]
		local 道具数据 = 玩家数据[id].道具.数据[道具编号]

		self:通灵重置丹处理(id, 装备编号, 道具编号, 装备数据, 道具数据, 玩家数据[id].道具.数据, 内容.装备编号, 内容.道具编号)
	elseif 序号 == 4510.4 then
		local 装备编号 = 玩家数据[id].角色.数据.道具[内容.装备编号]
		local 道具编号 = 玩家数据[id].角色.数据.道具[内容.道具编号]
		local 装备数据 = 玩家数据[id].道具.数据[装备编号]
		local 道具数据 = 玩家数据[id].道具.数据[道具编号]

		self:五行石处理(id, 装备编号, 道具编号, 装备数据, 道具数据, 玩家数据[id].道具.数据, 内容.装备编号, 内容.道具编号)
	elseif 序号 == 4510.3 then
		local 装备编号 = 玩家数据[id].角色.数据.道具[内容.装备编号]
		local 道具编号 = 玩家数据[id].角色.数据.道具[内容.道具编号]
		local 装备数据 = 玩家数据[id].道具.数据[装备编号]
		local 道具数据 = 玩家数据[id].道具.数据[道具编号]

		self:七彩石处理(id, 装备编号, 道具编号, 装备数据, 道具数据, 玩家数据[id].道具.数据, 内容.装备编号, 内容.道具编号)
	elseif 序号 == 4510.2 or 序号 == 4510.12 then
		local 装备编号 = 玩家数据[id].角色.数据.道具[内容.装备编号]
		local 道具编号 = 玩家数据[id].角色.数据.道具[内容.道具编号]
		local 装备数据 = 玩家数据[id].道具.数据[装备编号]
		local 道具数据 = 玩家数据[id].道具.数据[道具编号]

		if 序号 == 4510.2 then
			self:特效石处理(id, 装备编号, 道具编号, 装备数据, 道具数据, 玩家数据[id].道具.数据, 内容.装备编号, 内容.道具编号)
		else
			self:特技石处理(id, 装备编号, 道具编号, 装备数据, 道具数据, 玩家数据[id].道具.数据, 内容.装备编号, 内容.道具编号)
		end
	elseif 序号 == 4510.1 then
		local 装备编号 = 玩家数据[id].角色.数据.道具[内容.装备编号]
		local 分解符编号 = 玩家数据[id].角色.数据.道具[内容.分解符编号]

		打造处理类:分解装备处理(id, 装备编号, 分解符编号, 玩家数据[id].道具.数据[装备编号], 玩家数据[id].道具.数据[分解符编号], 玩家数据[id].道具.数据, 内容.装备编号, 内容.分解符编号)
		发送数据(玩家数据[id].连接id, 64.3)
	elseif 序号 == 4510 then
		if 内容.序列1 ~= nil or 内容.数据 ~= nil then
			local 刷新列表 = {}

			if 内容.序列1 ~= nil then
				self.临时id1 = 玩家数据[id].角色.数据.道具[内容.序列1]
				玩家数据[id].道具.数据[self.临时id1].数量 = (玩家数据[id].道具.数据[self.临时id1].数量 or 1) - 1

				if 玩家数据[id].道具.数据[self.临时id1].数量 < 1 then
					玩家数据[id].道具.数据[self.临时id1] = nil
				end

				self.临时id2 = 玩家数据[id].角色.数据.道具[内容.序列2]
				玩家数据[id].道具.数据[self.临时id2].鉴定 = true
				玩家数据[id].道具.数据[self.临时id2].耐久 = 取随机数(500, 1000)
				刷新列表[#刷新列表 + 1] = {
					内容.序列1,
					self.临时id1
				}
				刷新列表[#刷新列表 + 1] = {
					内容.序列2,
					self.临时id2
				}
			elseif 内容.数据 ~= nil then
				self.消耗体力 = floor(内容.数据.等级 / 2)

				if 玩家数据[id].角色.数据.体力 < self.消耗体力 then
					常规提示(id, "#Y/体力不够，无法鉴定该装备！")

					return
				else
					玩家数据[id].角色.数据.体力 = 玩家数据[id].角色.数据.体力 - self.消耗体力
					self.临时id2 = 玩家数据[id].角色.数据.道具[内容.序列2]
					玩家数据[id].道具.数据[self.临时id2].鉴定 = true
					玩家数据[id].道具.数据[self.临时id2].耐久 = 玩家数据[id].道具.数据[self.临时id2].耐久 or 取随机数(500, 7000)
				end

				刷新列表[#刷新列表 + 1] = {
					内容.序列2,
					self.临时id2
				}
			end

			local 装备1 = 玩家数据[id].道具.数据[self.临时id2]
			local 专用1 = 内容.专用

			if 专用1 == true then
				if 装备1.伤害 ~= nil then
					装备1.伤害 = math.ceil(装备1.伤害 * 取随机数(服务端参数.专用属性下限, 服务端参数.专用属性上限) / 1000)
				end

				if 装备1.灵力 ~= nil then
					装备1.灵力 = math.ceil(装备1.灵力 * 取随机数(服务端参数.专用属性下限, 服务端参数.专用属性上限) / 1000)
				end

				if 装备1.防御 ~= nil then
					装备1.防御 = math.ceil(装备1.防御 * 取随机数(服务端参数.专用属性下限, 服务端参数.专用属性上限) / 1000)
				end

				if 装备1.速度 ~= nil then
					装备1.速度 = math.ceil(装备1.速度 * 取随机数(服务端参数.专用属性下限, 服务端参数.专用属性上限) / 1000)
				end

				if 装备1.气血 ~= nil then
					装备1.气血 = math.ceil(装备1.气血 * 取随机数(服务端参数.专用属性下限, 服务端参数.专用属性上限) / 1000)
				end

				if 装备1.魔法 ~= nil then
					装备1.魔法 = math.ceil(装备1.魔法 * 取随机数(服务端参数.专用属性下限, 服务端参数.专用属性上限) / 1000)
				end

				if 装备1.力量 ~= nil then
					装备1.力量 = math.ceil(装备1.力量 * 取随机数(服务端参数.专用属性下限, 服务端参数.专用属性上限) / 1000)
				end

				if 装备1.魔力 ~= nil then
					装备1.魔力 = math.ceil(装备1.魔力 * 取随机数(服务端参数.专用属性下限, 服务端参数.专用属性上限) / 1000)
				end

				if 装备1.耐力 ~= nil then
					装备1.耐力 = math.ceil(装备1.耐力 * 取随机数(服务端参数.专用属性下限, 服务端参数.专用属性上限) / 1000)
				end

				if 装备1.体质 ~= nil then
					装备1.体质 = math.ceil(装备1.体质 * 取随机数(服务端参数.专用属性下限, 服务端参数.专用属性上限) / 1000)
				end

				if 装备1.敏捷 ~= nil then
					装备1.敏捷 = math.ceil(装备1.敏捷 * 取随机数(服务端参数.专用属性下限, 服务端参数.专用属性上限) / 1000)
				end

				if 装备1.躲避 ~= nil then
					装备1.躲避 = math.ceil(装备1.躲避 * 取随机数(服务端参数.专用属性下限, 服务端参数.专用属性上限) / 1000)
				end

				if 装备1.命中 ~= nil then
					装备1.命中 = math.ceil(装备1.命中 * 取随机数(服务端参数.专用属性下限, 服务端参数.专用属性上限) / 1000)
				end

				装备1.专用 = id
				玩家数据[id].道具.数据[self.临时id2] = 装备1
			end

			if 玩家数据[id].道具.数据[self.临时id2].特效 ~= nil and 玩家数据[id].道具.数据[self.临时id2].级别限制 >= 90 then
				local 特效判断 = {}

				if 玩家数据[id].道具.数据[self.临时id2].特效 ~= nil then
					特效判断 = 列表模式转换(玩家数据[id].道具.数据[self.临时id2].特效)
				end

				if 特效判断.无级别限制 ~= nil then
					广播消息({
						频道 = "xt",
						内容 = format("#Y恭喜玩家#G%s#Y非常幸运的鉴定出来一个#Z%s级无级别道具#Y让我们恭喜他#4", 玩家数据[id].角色.数据.名称, 玩家数据[id].道具.数据[self.临时id2].级别限制)
					})
				end
			end

			for i = 1, #刷新列表 do
				刷新道具行囊单格(id, "道具", 刷新列表[i][1], 刷新列表[i][2])
			end

			if 专用1 then
				常规提示(id, "#Y/恭喜你，该装备鉴定成功为您的专属装备，属性值大幅度提高了。")
			else
				常规提示(id, "#Y/恭喜你，装备鉴定成功!")
			end
		end
	elseif 序号 == 4511 then
		self:添加符石(id, 内容.道具id, 内容.装备id)
	elseif 序号 == 4512 then
		self:装备附魔(连接id, 序号, id, 内容)
	elseif 序号 == 4513 then
		self:技能附魔(连接id, 序号, id, 内容)
	elseif 序号 == 4514 then
		self:装备附魔宝珠(连接id, 序号, id, 内容)
	elseif 序号 == 4515 then
		self:装备碎星锤(连接id, 序号, id, 内容)
	elseif 序号 == 4516 then
		self:装备灵箓(连接id, 序号, id, 内容)
	elseif 序号 == 4517 then
		幻化处理类:数据处理(连接id, 序号, id, 内容)
	end
end

function 装备处理类:装备开启星位(连接id, 序号, id, 内容)
	local 装备编号 = 玩家数据[id].角色.数据.道具[内容.序列]

	if 玩家数据[id].道具.数据[装备编号].总类 ~= 2 or 玩家数据[id].道具.数据[装备编号].灵饰 or 玩家数据[id].道具.数据[装备编号].分类 > 6 then
		常规提示(id, "少侠，只有人物装备才可以开启星位。")

		return
	elseif 玩家数据[id].道具.数据[装备编号].级别限制 == nil and 玩家数据[id].道具.数据[装备编号].级别限制 < 60 then
		常规提示(id, "少侠，需要装备等级达到60级才可以开启星位。")

		return
	elseif 玩家数据[id].道具.数据[装备编号].开运孔数 == nil or 玩家数据[id].道具.数据[装备编号].开运孔数.上限 < 玩家数据[id].道具.数据[装备编号].开运孔数.当前 then
		常规提示(id, "少侠，你的装备孔数没满，不能开启星位。")

		return
	elseif 玩家数据[id].道具.数据[装备编号].星位组 ~= nil then
		常规提示(id, "少侠，你这件装备已经开启过星位了别闹了(&……*&")

		return
	end

	local 临时消耗 = 取开启星位消耗(玩家数据[id].道具.数据[装备编号].级别限制)

	if 玩家数据[id].角色.数据.银子 < 临时消耗.金钱 then
		常规提示(id, format("开启星位需要消耗#Z/%s#Y/两银子，你似乎手头有点紧哟？", 临时消耗.金钱))

		return
	elseif 玩家数据[id].角色.数据.当前经验 < 临时消耗.经验 then
		常规提示(id, format("开启星位需要消耗#Z/%s#Y/点经验，你似乎没有那么多的经验？", 临时消耗.经验))

		return
	end

	玩家数据[id].角色:扣除银子(临时消耗.金钱, 0, 0, "开启星位", 1)
	玩家数据[id].角色:扣除经验(临时消耗.经验, 0, 1)

	玩家数据[id].道具.数据[装备编号].星位组 = true

	常规提示(id, "#Z/恭喜你开启星位成功！")
	刷新道具行囊单格(id, "道具", 内容.序列, 装备编号)
	道具刷新(id, 1)
end

function 装备处理类:装备灵箓(连接id, 序号, id, 内容)
	self.临时id1 = 玩家数据[id].角色.数据.道具[内容.序列2]
	self.临时id2 = 玩家数据[id].角色.数据.道具[内容.序列1]

	if 玩家数据[id].道具.数据[self.临时id1] == nil or 玩家数据[id].道具.数据[self.临时id1] == 0 then
		常规提示(id, "你似乎并没有这样的道具")

		return 0
	elseif 玩家数据[id].道具.数据[self.临时id2] == nil then
		常规提示(id, "你似乎并没有这样的道具")

		return 0
	end

	if 玩家数据[id].道具.数据[self.临时id1].分类 < 10 or 玩家数据[id].道具.数据[self.临时id1].分类 > 13 then
		常规提示(id, "灵箓只能用于灵饰")

		return 0
	elseif 玩家数据[id].道具.数据[self.临时id2].名称 ~= "灵箓" then
		常规提示(id, "请不要移动灵箓的位置")

		return 0
	elseif 玩家数据[id].道具.数据[self.临时id1].灵饰 == nil then
		常规提示(id, "只有灵饰才可以使用此物品")

		return 0
	elseif 玩家数据[id].道具.数据[self.临时id1].附加特性 == nil or 玩家数据[id].道具.数据[self.临时id1].附加特性.幻化等级 == nil then
		常规提示(id, "该装备尚未附加特性")

		return 0
	end

	玩家数据[id].道具.数据[self.临时id1].附加特性 = nil
	玩家数据[id].角色.数据.道具[内容.序列1] = nil
	玩家数据[id].道具.数据[self.临时id2] = nil

	刷新道具行囊单格(id, "道具", 内容.序列1, self.临时id2)
	刷新道具行囊单格(id, "道具", 内容.序列2, self.临时id1)
	常规提示(id, "灵箓使用成功")
end

function 装备处理类:装备碎星锤(连接id, 序号, id, 内容)
	self.临时id1 = 玩家数据[id].角色.数据.道具[内容.序列2]
	self.临时id2 = 玩家数据[id].角色.数据.道具[内容.序列1]

	if 玩家数据[id].道具.数据[self.临时id1] == nil or 玩家数据[id].道具.数据[self.临时id1] == 0 then
		常规提示(id, "你似乎并没有这样的道具")

		return 0
	elseif 玩家数据[id].道具.数据[self.临时id2] == nil then
		常规提示(id, "你似乎并没有这样的道具")

		return 0
	end

	if 玩家数据[id].道具.数据[self.临时id1].分类 >= 7 then
		常规提示(id, "碎星锤只能用于装备")

		return 0
	elseif 玩家数据[id].道具.数据[self.临时id2].名称 ~= "碎星锤" and 玩家数据[id].道具.数据[self.临时id2].名称 ~= "超级碎星锤" then
		常规提示(id, "请不要移动碎星锤的位置")

		return 0
	elseif 玩家数据[id].道具.数据[self.临时id1].镶嵌类型 == nil or 玩家数据[id].道具.数据[self.临时id1].锻炼等级 == nil or 玩家数据[id].道具.数据[self.临时id1].锻炼等级 <= 0 then
		常规提示(id, "该装备尚未镶嵌任何宝石")

		return 0
	end

	local 最高宝石 = {}

	if 玩家数据[id].道具.数据[self.临时id2].名称 == "超级碎星锤" then
		local 镶嵌类型 = {
			{
				数量 = 1,
				类型 = 玩家数据[id].道具.数据[self.临时id1].镶嵌类型[1]
			}
		}

		for i = 2, 玩家数据[id].道具.数据[self.临时id1].锻炼等级 do
			if 玩家数据[id].道具.数据[self.临时id1].镶嵌类型[i] == 镶嵌类型[1].类型 then
				镶嵌类型[1].数量 = 镶嵌类型[1].数量 + 1
			elseif 镶嵌类型[2] ~= nil then
				镶嵌类型[2].数量 = 镶嵌类型[2].数量 + 1
			else
				镶嵌类型[2] = {
					数量 = 1,
					类型 = 玩家数据[id].道具.数据[self.临时id1].镶嵌类型[i]
				}
			end
		end

		最高宝石.名称 = 玩家数据[id].道具.数据[self.临时id1].镶嵌类型[#玩家数据[id].道具.数据[self.临时id1].镶嵌类型]
		最高宝石.等级 = 玩家数据[id].道具.数据[self.临时id1].锻炼等级

		for i = 1, #镶嵌类型 do
			if 镶嵌类型[i].类型 == "太阳石" then
				玩家数据[id].道具.数据[self.临时id1].伤害 = math.floor(玩家数据[id].道具.数据[self.临时id1].伤害 - 镶嵌类型[i].数量 * 8)
			elseif 镶嵌类型[i].类型 == "红玛瑙" then
				玩家数据[id].道具.数据[self.临时id1].命中 = math.floor(玩家数据[id].道具.数据[self.临时id1].命中 - 镶嵌类型[i].数量 * 25)
			elseif 镶嵌类型[i].类型 == "月亮石" then
				玩家数据[id].道具.数据[self.临时id1].防御 = math.floor(玩家数据[id].道具.数据[self.临时id1].防御 - 镶嵌类型[i].数量 * 12)
			elseif 镶嵌类型[i].类型 == "黑宝石" then
				玩家数据[id].道具.数据[self.临时id1].速度 = math.floor(玩家数据[id].道具.数据[self.临时id1].速度 - 镶嵌类型[i].数量 * 8)
			elseif 镶嵌类型[i].类型 == "舍利子" then
				玩家数据[id].道具.数据[self.临时id1].灵力 = math.floor(玩家数据[id].道具.数据[self.临时id1].灵力 - 镶嵌类型[i].数量 * 6)
			elseif 镶嵌类型[i].类型 == "光芒石" then
				玩家数据[id].道具.数据[self.临时id1].气血 = math.floor(玩家数据[id].道具.数据[self.临时id1].气血 - 镶嵌类型[i].数量 * 40)
			elseif 镶嵌类型[i].类型 == "神秘石" then
				玩家数据[id].道具.数据[self.临时id1].躲避 = math.floor(玩家数据[id].道具.数据[self.临时id1].躲避 - 镶嵌类型[i].数量 * 20)
			end
		end

		玩家数据[id].道具.数据[self.临时id1].锻炼等级 = nil
		玩家数据[id].道具.数据[self.临时id1].镶嵌宝石 = nil
		玩家数据[id].道具.数据[self.临时id1].镶嵌类型 = nil
	elseif 玩家数据[id].道具.数据[self.临时id2].名称 == "碎星锤" then
		local 镶嵌类型 = 玩家数据[id].道具.数据[self.临时id1].镶嵌类型[#玩家数据[id].道具.数据[self.临时id1].镶嵌类型]

		if 镶嵌类型 == "太阳石" then
			玩家数据[id].道具.数据[self.临时id1].伤害 = math.floor(玩家数据[id].道具.数据[self.临时id1].伤害 - 8)
		elseif 镶嵌类型 == "红玛瑙" then
			玩家数据[id].道具.数据[self.临时id1].命中 = math.floor(玩家数据[id].道具.数据[self.临时id1].命中 - 25)
		elseif 镶嵌类型 == "月亮石" then
			玩家数据[id].道具.数据[self.临时id1].防御 = math.floor(玩家数据[id].道具.数据[self.临时id1].防御 - 12)
		elseif 镶嵌类型 == "黑宝石" then
			玩家数据[id].道具.数据[self.临时id1].速度 = math.floor(玩家数据[id].道具.数据[self.临时id1].速度 - 8)
		elseif 镶嵌类型 == "舍利子" then
			玩家数据[id].道具.数据[self.临时id1].灵力 = math.floor(玩家数据[id].道具.数据[self.临时id1].灵力 - 6)
		elseif 镶嵌类型 == "光芒石" then
			玩家数据[id].道具.数据[self.临时id1].气血 = math.floor(玩家数据[id].道具.数据[self.临时id1].气血 - 40)
		elseif 镶嵌类型 == "神秘石" then
			玩家数据[id].道具.数据[self.临时id1].躲避 = math.floor(玩家数据[id].道具.数据[self.临时id1].躲避 - 20)
		end

		玩家数据[id].道具.数据[self.临时id1].锻炼等级 = 玩家数据[id].道具.数据[self.临时id1].锻炼等级 - 1

		if 玩家数据[id].道具.数据[self.临时id1].锻炼等级 <= 0 then
			玩家数据[id].道具.数据[self.临时id1].锻炼等级 = nil
			玩家数据[id].道具.数据[self.临时id1].镶嵌宝石 = nil
			玩家数据[id].道具.数据[self.临时id1].镶嵌类型 = nil
		else
			玩家数据[id].道具.数据[self.临时id1].镶嵌类型[#玩家数据[id].道具.数据[self.临时id1].镶嵌类型] = nil

			if #玩家数据[id].道具.数据[self.临时id1].镶嵌宝石 >= 2 then
				local 找到 = false

				for n = 1, #玩家数据[id].道具.数据[self.临时id1].镶嵌类型 do
					if 玩家数据[id].道具.数据[self.临时id1].镶嵌宝石[1] == 玩家数据[id].道具.数据[self.临时id1].镶嵌类型[n] then
						找到 = true

						break
					end
				end

				if 找到 == false then
					table.remove(玩家数据[id].道具.数据[self.临时id1].镶嵌宝石, 1)
				else
					找到 = false

					for n = 1, #玩家数据[id].道具.数据[self.临时id1].镶嵌类型 do
						if 玩家数据[id].道具.数据[self.临时id1].镶嵌宝石[2] == 玩家数据[id].道具.数据[self.临时id1].镶嵌类型[n] then
							找到 = true

							break
						end
					end

					if 找到 == false then
						table.remove(玩家数据[id].道具.数据[self.临时id1].镶嵌宝石, 2)
					end
				end
			end
		end
	end

	玩家数据[id].角色.数据.道具[内容.序列1] = nil
	玩家数据[id].道具.数据[self.临时id2] = nil

	if 最高宝石.等级 ~= nil and 最高宝石.名称 ~= nil then
		玩家数据[id].道具:给予道具(id, 最高宝石.名称, 最高宝石.等级)
	end

	刷新道具行囊单格(id, "道具", 内容.序列1, self.临时id2)
	刷新道具行囊单格(id, "道具", 内容.序列2, self.临时id1)
	常规提示(id, "碎星锤使用成功")
end

function 装备处理类:装备附魔宝珠(连接id, 序号, id, 内容)
	self.临时id1 = 玩家数据[id].角色.数据.道具[内容.序列2]
	self.临时id2 = 玩家数据[id].角色.数据.道具[内容.序列1]

	if 玩家数据[id].道具.数据[self.临时id1] == nil or 玩家数据[id].道具.数据[self.临时id1] == 0 then
		常规提示(id, "你似乎并没有这样的道具")

		return 0
	elseif 玩家数据[id].道具.数据[self.临时id2] == nil then
		常规提示(id, "你似乎并没有这样的道具")

		return 0
	elseif 玩家数据[id].道具.数据[self.临时id2].名称 ~= "附魔宝珠" then
		常规提示(id, "请不要移动附魔宝珠的位置！")

		return 0
	end

	if 玩家数据[id].道具.数据[self.临时id1].分类 >= 7 then
		常规提示(id, "该物品无法开孔")

		return 0
	end

	local 套装类型 = {
		"附加状态",
		"追加法术"
	}
	套装类型 = 套装类型[取随机数(1, #套装类型)]
	local 套装效果 = {
		附加状态 = {
			"金刚护法",
			"金刚护体",
			"生命之泉",
			"炼气化神",
			"普渡众生",
			"定心术",
			"碎星诀",
			"变身",
			"凝神术",
			"逆鳞",
			"不动如山",
			"法术防御",
			"明光宝烛",
			"天神护体",
			"移魂化骨",
			"蜜润",
			"杀气诀",
			"韦陀护法",
			"一苇渡江",
			"天神护法",
			"乘风破浪",
			"魔息术",
			"盘丝阵",
			"炎护"
		},
		追加法术 = {
			"横扫千军",
			"善恶有报",
			"惊心一剑",
			"壁垒击破",
			"满天花雨",
			"浪涌",
			"唧唧歪歪",
			"五雷咒",
			"龙卷雨击",
			"剑荡四方",
			"裂石",
			"烟雨剑法",
			"天雷斩",
			"力劈华山",
			"夜舞倾城",
			"上古灵符",
			"叱咤风云",
			"天降灵葫",
			"月光",
			"八凶法阵",
			"死亡召唤",
			"天罗地网",
			"夺命咒",
			"落叶萧萧",
			"落雷符",
			"雨落寒沙",
			"苍茫树",
			"飞砂走石",
			"阎罗令",
			"水攻",
			"烈火",
			"落岩",
			"雷击",
			"泰山压顶",
			"水漫金山",
			"地狱烈火",
			"奔雷咒"
		}
	}
	玩家数据[id].道具.数据[self.临时id1].套装效果 = {
		套装类型,
		套装效果[套装类型][取随机数(1, #套装效果[套装类型])]
	}
	玩家数据[id].角色.数据.道具[内容.序列1] = nil
	玩家数据[id].道具.数据[self.临时id2] = nil

	刷新道具行囊单格(id, "道具", 内容.序列1, self.临时id2)
	刷新道具行囊单格(id, "道具", 内容.序列2, self.临时id1)
	常规提示(id, "附魔宝珠使用成功")
end

function 装备处理类:技能附魔(连接id, 序号, id, 内容)
	self.临时id1 = 玩家数据[id].角色.数据.道具[内容.序列2]

	if 玩家数据[id].道具.数据[self.临时id1] == nil or 玩家数据[id].道具.数据[self.临时id1] == 0 then
		常规提示(id, "你似乎并没有这样的道具")

		return 0
	end

	self.到期时间 = os.time() + 604800

	if 附魔技能列表[内容.数据.名称] == nil then
		常规提示(id, "附魔技能错误！")

		return
	elseif 内容.数据.等级 <= 玩家数据[id].角色.数据.活力 then
		local aa = 附魔技能列表[内容.数据.名称]
		self.临时数值 = math.floor(取随机数(内容.数据.等级 * aa[2], 内容.数据.等级 * aa[3]))

		if 玩家数据[id].道具.数据[self.临时id1].临时附魔 == nil then
			玩家数据[id].道具.数据[self.临时id1].临时附魔 = {}
		end

		if 玩家数据[id].道具.数据[self.临时id1].临时附魔[aa[1]] == nil then
			玩家数据[id].道具.数据[self.临时id1].临时附魔[aa[1]] = {
				数值 = 0,
				时间 = 0
			}
		end

		玩家数据[id].道具.数据[self.临时id1].临时附魔[aa[1]].数值 = self.临时数值
		玩家数据[id].道具.数据[self.临时id1].临时附魔[aa[1]].时间 = 时间转换2(self.到期时间)
		玩家数据[id].角色.数据.活力 = 玩家数据[id].角色.数据.活力 - 内容.数据.等级

		刷新道具行囊单格(id, "道具", 内容.序列2, self.临时id1)
		常规提示(id, "添加临时附魔成功")
	else
		常规提示(id, "活力不足,无法附魔")
	end
end

function 装备处理类:装备附魔(连接id, 序号, id, 内容)
	self.临时id1 = 玩家数据[id].角色.数据.道具[内容.序列2]
	self.临时id2 = 玩家数据[id].角色.数据.道具[内容.序列1]

	if 玩家数据[id].道具.数据[self.临时id1] == nil or 玩家数据[id].道具.数据[self.临时id1] == 0 then
		常规提示(id, "你似乎并没有这样的道具")

		return 0
	end

	self.到期时间 = os.time() + 604800
	local jnmc = 玩家数据[id].道具.数据[self.临时id2].类型

	if 附魔技能列表[jnmc] == nil then
		常规提示(id, "附魔技能错误！")

		return
	end

	local aa = 附魔技能列表[jnmc]
	self.临时数值 = math.floor(取随机数(玩家数据[id].道具.数据[self.临时id2].等级 * aa[2], 玩家数据[id].道具.数据[self.临时id2].等级 * aa[3]))

	if 玩家数据[id].道具.数据[self.临时id1].临时附魔 == nil then
		玩家数据[id].道具.数据[self.临时id1].临时附魔 = {}
	end

	if 玩家数据[id].道具.数据[self.临时id1].临时附魔[aa[1]] == nil then
		玩家数据[id].道具.数据[self.临时id1].临时附魔[aa[1]] = {
			数值 = 0,
			时间 = 0
		}
	end

	玩家数据[id].道具.数据[self.临时id1].临时附魔[aa[1]].数值 = self.临时数值
	玩家数据[id].道具.数据[self.临时id1].临时附魔[aa[1]].时间 = 时间转换2(self.到期时间)
	玩家数据[id].道具.数据[self.临时id2] = nil

	常规提示(id, "附魔成功！")
	刷新道具行囊单格(id, "道具", 内容.序列1, self.临时id2)
	刷新道具行囊单格(id, "道具", 内容.序列2, self.临时id1)
end

取开孔消耗 = function(装备级别)
	if 装备级别 <= 30 then
		return {
			体力 = 4,
			银两 = 100000
		}
	elseif 装备级别 <= 60 then
		return {
			体力 = 8,
			银两 = 200000
		}
	elseif 装备级别 <= 90 then
		return {
			体力 = 12,
			银两 = 300000
		}
	elseif 装备级别 <= 120 then
		return {
			体力 = 16,
			银两 = 400000
		}
	elseif 装备级别 <= 150 then
		return {
			体力 = 20,
			银两 = 500000
		}
	elseif 装备级别 <= 160 then
		return {
			体力 = 24,
			银两 = 600000
		}
	end
end

function 装备处理类:装备开运(连接id, 序号, id, 内容)
	self.临时id1 = 玩家数据[id].角色.数据.道具[内容.序列]

	if 玩家数据[id].道具.数据[self.临时id1] == nil or 玩家数据[id].道具.数据[self.临时id1] == 0 then
		常规提示(id, "你似乎并没有这样的道具")

		return 0
	elseif 玩家数据[id].道具.数据[self.临时id1].级别限制 == nil then
		常规提示(id, "该物品无法开孔")

		return 0
	elseif 玩家数据[id].道具.数据[self.临时id1].分类 >= 7 then
		常规提示(id, "该物品无法开孔")

		return 0
	elseif 玩家数据[id].道具.数据[self.临时id1].耐久 < 6 then
		常规提示(id, "该装备耐久度过低、无法开运。")

		return 0
	elseif 玩家数据[id].道具.数据[self.临时id1].开运孔数 == nil then
		玩家数据[id].道具.数据[self.临时id1].开运孔数 = {
			当前 = 0,
			上限 = math.floor(玩家数据[id].道具.数据[self.临时id1].级别限制 / 32.5 + 1)
		}
	end

	if 玩家数据[id].道具.数据[self.临时id1].开运孔数.当前 < 玩家数据[id].道具.数据[self.临时id1].开运孔数.上限 and 玩家数据[id].道具.数据[self.临时id1].开运孔数.当前 < 6 then
		local aa = 取开孔消耗(玩家数据[id].道具.数据[self.临时id1].级别限制)
		self.扣除金钱 = aa.银两
		self.消耗体力 = aa.体力

		if 玩家数据[id].角色.数据.银子 < self.扣除金钱 then
			常规提示(id, "你没那么多的银子")

			return 0
		elseif 玩家数据[id].角色.数据.体力 < self.消耗体力 then
			常规提示(id, "你没那么多的体力")

			return 0
		end

		local 装备几率 = nil

		if 玩家数据[id].道具.数据[self.临时id1].级别限制 <= 30 then
			装备几率 = 80
		elseif 玩家数据[id].道具.数据[self.临时id1].级别限制 <= 60 then
			装备几率 = 65
		elseif 玩家数据[id].道具.数据[self.临时id1].级别限制 <= 90 then
			装备几率 = 50
		elseif 玩家数据[id].道具.数据[self.临时id1].级别限制 <= 120 then
			装备几率 = 35
		elseif 玩家数据[id].道具.数据[self.临时id1].级别限制 <= 150 then
			装备几率 = 20
		else
			装备几率 = 15
		end

		玩家数据[id].道具.数据[self.临时id1].耐久 = 玩家数据[id].道具.数据[self.临时id1].耐久 - 5

		常规提示(id, "你的#P" .. 玩家数据[id].道具.数据[self.临时id1].名称 .. "#Y耐久度减少了#R5#Y点。")

		if ygsj() <= 装备几率 then
			玩家数据[id].道具.数据[self.临时id1].开运孔数.当前 = 玩家数据[id].道具.数据[self.临时id1].开运孔数.当前 + 1

			玩家数据[id].角色:扣除银子(self.扣除金钱, 0, 0, "符石开孔", 1)

			玩家数据[id].角色.数据.体力 = 玩家数据[id].角色.数据.体力 - self.消耗体力

			常规提示(id, "你消耗了:" .. self.扣除金钱 .. "金钱" .. self.消耗体力 .. "体力")
			常规提示(id, "装备开孔成功")
		else
			玩家数据[id].角色:扣除银子(self.扣除金钱, 0, 0, "符石开孔", 1)

			玩家数据[id].角色.数据.体力 = 玩家数据[id].角色.数据.体力 - self.消耗体力

			常规提示(id, "你消耗了:" .. self.扣除金钱 .. "金钱" .. self.消耗体力 .. "体力")
			常规提示(id, "装备开孔失败")
		end

		self.发送信息 = {
			体力 = 玩家数据[id].角色.数据.体力,
			银子 = 玩家数据[id].角色.数据.银子
		}

		发送数据(玩家数据[id].连接id, 63, self.发送信息)
	else
		常规提示(id, "#r/装备已经无法再进行开孔了")
	end
end

function 装备处理类:添加符石(id, 道具id, 装备id)
	道具id = 分割文本(道具id, ",")
	local 临时id = {}
	local 临时装备id = 玩家数据[id].角色.数据.道具[装备id]

	for i = 1, 5 do
		道具id[i] = 道具id[i] + 0
		临时id[i] = 玩家数据[id].角色.数据.道具[道具id[i]]

		if 玩家数据[id].道具.数据[临时id[i]] ~= nil and 道具id[i] ~= 0 then
			if 玩家数据[id].道具.数据[临时id[i]].总类 == 55 then
				if 玩家数据[id].道具.数据[临时装备id].符石 == nil then
					玩家数据[id].道具.数据[临时装备id].符石 = {}
				end

				玩家数据[id].道具.数据[临时装备id].符石[i] = table.loadstring(table.tostring(玩家数据[id].道具.数据[临时id[i]]))

				常规提示(id, "镶嵌符石成功")

				玩家数据[id].道具.数据[临时id[i]] = nil
				玩家数据[id].角色.数据.道具[道具id[i]] = nil
			else
				常规提示(id, "只能镶嵌符石")

				return
			end
		end
	end

	符石置对象(id, 临时装备id)
	刷新道具行囊单格(id, "道具", 装备id, 临时装备id)
end

function 装备处理类:宝石合成处理(连接id, 序号, id, 内容)
	local 行囊格子 = 玩家数据[id].角色:取道具格子()

	if 行囊格子 == 0 then
		常规提示(id, "您的道具栏物品已经满啦")

		return
	end

	local 不可交易 = false
	local 格子1 = 玩家数据[id].角色.数据.道具[内容.序列]
	local 格子2 = 玩家数据[id].角色.数据.道具[内容.序列1]

	if 玩家数据[id].道具.数据[格子1] == nil or 玩家数据[id].道具.数据[格子2] == nil then
		道具刷新(id)

		return
	elseif 内容.序列 == 内容.序列1 and (玩家数据[id].道具.数据[格子1].数量 or 1) <= 1 then
		常规提示(id, "同一格子合成数量不足")

		return
	end

	if 玩家数据[id].道具.数据[格子1].不可交易 == true or 玩家数据[id].道具.数据[格子2].不可交易 == true then
		不可交易 = true
	end

	if 玩家数据[id].道具.数据[格子1].总类 == 2 and 玩家数据[id].道具.数据[格子1].分类 == 9 and 玩家数据[id].道具.数据[格子2].总类 == 2 and 玩家数据[id].道具.数据[格子2].分类 == 9 and 通灵装备1[玩家数据[id].道具.数据[格子1].名称] ~= nil then
		if 玩家数据[id].道具.数据[格子1].名称 ~= 玩家数据[id].道具.数据[格子2].名称 then
			常规提示(id, "只有类型相同的通灵装备才可以合成")

			return
		elseif 玩家数据[id].角色.数据.体力 < (玩家数据[id].道具.数据[格子1].等级 or 1) * 10 then
			常规提示(id, "你没有那么多的体力")

			return
		else
			玩家数据[id].道具.数据[格子1].等级 = 取护符等级(玩家数据[id].道具.数据[格子1].名称)

			if 玩家数据[id].道具.数据[格子1].等级 < 3 and (取随机数(1, 1000) <= 通灵装备合成更高级别概率 or 玩家数据[id].道具.数据[格子1].附带技能 ~= nil and #玩家数据[id].道具.数据[格子1].附带技能 >= 2 and 玩家数据[id].道具.数据[格子2].附带技能 ~= nil and #玩家数据[id].道具.数据[格子2].附带技能 >= 2 and 取随机数(1, 1000) <= 通灵装备合成更高级别概率 * 6) then
				玩家数据[id].道具.数据[格子1].等级 = 玩家数据[id].道具.数据[格子1].等级 + 1
				玩家数据[id].道具.数据[格子1].名称 = 通灵装备[玩家数据[id].道具.数据[格子1].等级]
				玩家数据[id].道具.数据[格子1].附带技能 = {}
				玩家数据[id].道具.数据[格子2].附带技能 = {}

				常规提示(id, "#Y恭喜你合成出#R更高级别#Y的通灵装备！你得到了一件全新的#R" .. 玩家数据[id].道具.数据[格子1].名称)
			else
				常规提示(id, "合成成功！你得到了一件新的#R" .. 玩家数据[id].道具.数据[格子1].名称)
			end

			local 双技能 = false
			local 合成次数 = 0

			if 玩家数据[id].道具.数据[格子1].附带技能 ~= nil and #玩家数据[id].道具.数据[格子1].附带技能 >= 2 or 玩家数据[id].道具.数据[格子2].附带技能 ~= nil and #玩家数据[id].道具.数据[格子2].附带技能 >= 2 then
				双技能 = true
				玩家数据[id].道具.数据[格子1].附带技能 = 取护符技能(玩家数据[id].道具.数据[格子1].名称, 2)

				常规提示(id, "(合成材料中至少有一个是双技能)你得到了一件双技能的#R" .. 玩家数据[id].道具.数据[格子1].名称)
			else
				if 玩家数据[id].道具.数据[格子1].合成次数 ~= nil and 玩家数据[id].道具.数据[格子2].合成次数 ~= nil then
					合成次数 = 玩家数据[id].道具.数据[格子1].合成次数 + 玩家数据[id].道具.数据[格子2].合成次数
				elseif 玩家数据[id].道具.数据[格子1].合成次数 ~= nil or 玩家数据[id].道具.数据[格子2].合成次数 ~= nil then
					合成次数 = 玩家数据[id].道具.数据[格子1].合成次数 or 玩家数据[id].道具.数据[格子2].合成次数
				else
					合成次数 = 0
				end

				合成次数 = 合成次数 + 1

				if 通灵双技能保底 <= 合成次数 then
					玩家数据[id].道具.数据[格子1].附带技能 = 取护符技能(玩家数据[id].道具.数据[格子1].名称, 2)

					常规提示(id, "触发保底机制(装备合成单技能次数达到" .. 通灵双技能保底 .. "次)！你得到了一件双技能的#R" .. 玩家数据[id].道具.数据[格子1].名称)
				else
					玩家数据[id].道具.数据[格子1].附带技能 = 取护符技能(玩家数据[id].道具.数据[格子1].名称)

					if #玩家数据[id].道具.数据[格子1].附带技能 == 2 then
						常规提示(id, "恭喜！本次合成你得到了一件双技能的#R" .. 玩家数据[id].道具.数据[格子1].名称)
					end
				end
			end

			if #玩家数据[id].道具.数据[格子1].附带技能 < 2 then
				玩家数据[id].道具.数据[格子1].合成次数 = 合成次数
			else
				玩家数据[id].道具.数据[格子1].合成次数 = nil
			end

			玩家数据[id].道具.数据[格子1].次数 = 2

			if 不可交易 then
				玩家数据[id].道具.数据[格子1].不可交易 = 不可交易
			end

			玩家数据[id].道具.数据[格子2] = nil
			玩家数据[id].角色.数据.道具[内容.序列1] = nil

			刷新道具行囊单格(id, "道具", 内容.序列, 格子1)
			刷新道具行囊单格(id, "道具", 内容.序列1, 格子2)

			return
		end
	elseif 书铁列表1[玩家数据[id].道具.数据[格子1].名称] ~= nil and 玩家数据[id].道具.数据[格子1].总类 == 5 and 玩家数据[id].道具.数据[格子1].总类 == 玩家数据[id].道具.数据[格子2].总类 and 玩家数据[id].道具.数据[格子1].分类 == 玩家数据[id].道具.数据[格子2].分类 and (玩家数据[id].道具.数据[格子1].分类 == 1 or 玩家数据[id].道具.数据[格子1].分类 == 2 or 玩家数据[id].道具.数据[格子1].分类 == 20 or 玩家数据[id].道具.数据[格子1].分类 == 21) then
		if 玩家数据[id].道具.数据[格子1].名称 ~= 玩家数据[id].道具.数据[格子2].名称 then
			常规提示(id, "只有相同的道具才可以合成")

			return
		elseif 玩家数据[id].道具.数据[格子1].子类 ~= 玩家数据[id].道具.数据[格子2].子类 then
			常规提示(id, "只有等级相同的书铁才可以合成")

			return
		elseif 玩家数据[id].角色.数据.体力 < 玩家数据[id].道具.数据[格子1].子类 then
			常规提示(id, "你没有那么多的体力")

			return
		elseif 玩家数据[id].道具.数据[格子1].子类 >= 130 then
			常规提示(id, "无法合成")

			return
		else
			玩家数据[id].角色.数据.体力 = 玩家数据[id].角色.数据.体力 - 玩家数据[id].道具.数据[格子1].子类

			体活刷新(id)

			local 新格子 = 玩家数据[id].道具:取新编号()
			玩家数据[id].角色.数据.道具[行囊格子] = 新格子
			玩家数据[id].道具.数据[新格子] = DeepCopy(玩家数据[id].道具.数据[格子1])
			玩家数据[id].道具.数据[新格子].子类 = 玩家数据[id].道具.数据[格子1].子类 + 10
			玩家数据[id].道具.数据[新格子].数量 = 1

			if 不可交易 then
				玩家数据[id].道具.数据[新格子].不可交易 = 不可交易
				local 购买价格 = {
					0,
					0
				}

				if 玩家数据[id].道具.数据[格子1].购买价格 ~= nil then
					购买价格[1] = 购买价格[1] + 玩家数据[id].道具.数据[格子1].购买价格
					购买价格[2] = 购买价格[2] + 1
				end

				if 玩家数据[id].道具.数据[格子2].购买价格 ~= nil then
					购买价格[1] = 购买价格[1] + 玩家数据[id].道具.数据[格子2].购买价格
					购买价格[2] = 购买价格[2] + 1
				end

				if 购买价格[1] > 0 then
					玩家数据[id].道具.数据[新格子].购买价格 = qz(购买价格[1] / 购买价格[2] * 2)
				end
			end

			刷新道具行囊单格(id, "道具", 行囊格子, 新格子)
			扣除背包位置道具(id, 内容.序列, 1)
			扣除背包位置道具(id, 内容.序列1, 1)
			常规提示(id, "你合成了一个更高级的" .. 玩家数据[id].道具.数据[新格子].名称)

			return
		end
	elseif 玩家数据[id].道具.数据[格子1].名称 == "怪物卡片" and 玩家数据[id].道具.数据[格子2].名称 == "怪物卡片" then
		if 玩家数据[id].道具.数据[格子1].等级 ~= 玩家数据[id].道具.数据[格子2].等级 then
			常规提示(id, "只有相同等级的怪物卡片才可以合成")

			return
		elseif 玩家数据[id].道具.数据[格子1].造型 ~= 玩家数据[id].道具.数据[格子2].造型 then
			常规提示(id, "只有相同造型的怪物卡片才可以合成")

			return
		elseif 玩家数据[id].道具.数据[格子1].技能 ~= 玩家数据[id].道具.数据[格子2].技能 then
			常规提示(id, "只有相同技能的怪物卡片才可以合成")

			return
		elseif 玩家数据[id].道具.数据[格子1].次数 >= 9 or 玩家数据[id].道具.数据[格子2].次数 >= 9 then
			常规提示(id, "怪物卡片可使用次数>8次、无需合成！")

			return
		elseif 角色扣除体力(id, 玩家数据[id].道具.数据[格子1].等级 * 10) == false then
			return
		else
			local 新格子 = 玩家数据[id].道具:取新编号()
			玩家数据[id].角色.数据.道具[行囊格子] = 新格子
			玩家数据[id].道具.数据[新格子] = DeepCopy(玩家数据[id].道具.数据[格子1])
			玩家数据[id].道具.数据[新格子].次数 = math.min(玩家数据[id].道具.数据[格子1].次数 + 玩家数据[id].道具.数据[格子2].次数, 9)
			玩家数据[id].道具.数据[新格子].数量 = 1

			刷新道具行囊单格(id, "道具", 行囊格子, 新格子)
			扣除背包位置道具(id, 内容.序列1, 1)
			扣除背包位置道具(id, 内容.序列, 1)
			常规提示(id, "怪物卡片合成成功、可使用次数增加了！")
		end
	elseif 玩家数据[id].道具.数据[格子1].总类 == 5 and 玩家数据[id].道具.数据[格子1].分类 == 6 and 玩家数据[id].道具.数据[格子2].总类 == 5 and 玩家数据[id].道具.数据[格子2].分类 == 6 then
		if 玩家数据[id].道具.数据[格子1].名称 ~= 玩家数据[id].道具.数据[格子2].名称 then
			常规提示(id, "只有类型相同的宝石才可以合成")

			return
		elseif 玩家数据[id].道具.数据[格子1].名称 == "星辉石" then
			常规提示(id, "星辉石请在背包点击右键合成")

			return
		elseif 玩家数据[id].道具.数据[格子1].级别限制 ~= 玩家数据[id].道具.数据[格子2].级别限制 then
			常规提示(id, "只有等级相同的宝石才可以合成")

			return
		elseif 玩家数据[id].角色.数据.体力 < 玩家数据[id].道具.数据[格子1].级别限制 * 10 then
			常规提示(id, "你没有那么多的体力")

			return
		else
			玩家数据[id].角色.数据.体力 = 玩家数据[id].角色.数据.体力 - 玩家数据[id].道具.数据[格子1].级别限制

			体活刷新(id)

			local 合成成功 = false
			local 最终等级 = 0

			if 玩家数据[id].道具.数据[格子1].名称 == "钟灵石" then
				local 概率 = f函数.读配置(程序目录 .. "配置文件.ini", "主要配置", "钟灵石基础概率")
				local 降低 = f函数.读配置(程序目录 .. "配置文件.ini", "主要配置", "钟灵石等级降低")

				if tonumber(概率) == nil then
					概率 = 100
				end

				概率 = tonumber(概率)

				if tonumber(降低) == nil then
					降低 = 5
				end

				降低 = tonumber(降低)

				if ygsj() <= 概率 - 降低 * 玩家数据[id].道具.数据[格子1].级别限制 then
					local dj = 1

					if ygsj() <= 钟灵石合成跳级 then
						dj = dj + 1

						常规提示(id, "#Y幸运天降、你合成的钟灵石#R跳级#Y啦！")
					end

					最终等级 = 玩家数据[id].道具.数据[格子1].级别限制 + dj
					合成成功 = true
				else
					扣除背包位置道具(id, 内容.序列1, 1)
					常规提示(id, "合成失败，你因此损失了一颗宝石")
				end
			elseif self:取宝石合成几率(id, 玩家数据[id].道具.数据[格子1].级别限制) then
				最终等级 = 玩家数据[id].道具.数据[格子1].级别限制 + 1
				合成成功 = true
			else
				扣除背包位置道具(id, 内容.序列1, 1)
				常规提示(id, "合成失败，你因此损失了一颗宝石")
			end

			if 合成成功 and 最终等级 > 0 then
				local 新格子 = 玩家数据[id].道具:取新编号()
				玩家数据[id].角色.数据.道具[行囊格子] = 新格子
				玩家数据[id].道具.数据[新格子] = DeepCopy(玩家数据[id].道具.数据[格子1])
				玩家数据[id].道具.数据[新格子].级别限制 = 最终等级 + 0
				玩家数据[id].道具.数据[新格子].数量 = 1

				if 不可交易 then
					玩家数据[id].道具.数据[新格子].不可交易 = 不可交易
					local 购买价格 = {
						0,
						0
					}

					if 玩家数据[id].道具.数据[格子1].购买价格 ~= nil then
						购买价格[1] = 购买价格[1] + 玩家数据[id].道具.数据[格子1].购买价格
						购买价格[2] = 购买价格[2] + 1
					end

					if 玩家数据[id].道具.数据[格子2].购买价格 ~= nil then
						购买价格[1] = 购买价格[1] + 玩家数据[id].道具.数据[格子2].购买价格
						购买价格[2] = 购买价格[2] + 1
					end

					if 购买价格[1] > 0 then
						玩家数据[id].道具.数据[新格子].购买价格 = qz(购买价格[1] / 购买价格[2] * 2)
					end
				end

				刷新道具行囊单格(id, "道具", 行囊格子, 新格子)
				扣除背包位置道具(id, 内容.序列, 1)
				扣除背包位置道具(id, 内容.序列1, 1)
				常规提示(id, "你合成了一个更高级的" .. 玩家数据[id].道具.数据[新格子].名称)
			end
		end

		return
	end
end

function 装备处理类:装备修理处理(连接id, 序号, id, 内容)
	local 格子1 = 玩家数据[id].角色.数据.道具[内容.序列]
	local 格子2 = 玩家数据[id].角色.数据.道具[内容.序列1]

	if 格子1 == nil or 格子2 == nil or 玩家数据[id].道具.数据[格子1] == nil or 玩家数据[id].道具.数据[格子2] == nil then
		道具刷新(id)

		return
	end

	local 装备格子, 珍珠格子, 珍珠编号, 装备编号 = nil

	if 玩家数据[id].道具.数据[格子1].名称 == "珍珠" then
		珍珠格子 = 格子1
		装备格子 = 格子2
		珍珠编号 = 内容.序列
		装备编号 = 内容.序列1
	elseif 玩家数据[id].道具.数据[格子2].名称 == "珍珠" then
		珍珠格子 = 格子2
		装备格子 = 格子1
		珍珠编号 = 内容.序列1
		装备编号 = 内容.序列
	end

	if 珍珠格子 == nil then
		常规提示(id, "#Y/请放入珍珠！")

		return
	elseif 玩家数据[id].道具.数据[装备格子].总类 ~= 2 then
		常规提示(id, "#Y/只有装备才可以进行修理")

		return
	elseif 玩家数据[id].道具.数据[装备格子].耐久 >= 500 then
		常规提示(id, "#Y/目前该装备无需修理")

		return
	elseif 玩家数据[id].道具.数据[装备格子].耐久 == nil then
		常规提示(id, "#Y/该物品无法修理")

		return
	elseif 玩家数据[id].道具.数据[装备格子].修理失败 ~= nil and 玩家数据[id].道具.数据[装备格子].修理失败 >= 3 then
		常规提示(id, "#Y/该装备已经无法修理")

		return
	elseif 玩家数据[id].道具.数据[珍珠格子].级别限制 < 玩家数据[id].道具.数据[装备格子].级别限制 then
		常规提示(id, "#Y/该珍珠等级过低！")

		return
	end

	local 修理费用 = math.floor(玩家数据[id].道具.数据[装备格子].级别限制 / 500 * 15000 * 300)

	if 取银子(id) < 修理费用 then
		常规提示(id, "#Y/你身上的银子不够#R" .. 数字转简(修理费用) .. "、#Y修理该装备！")

		return
	end

	if 扣除指定位置道具(id, 珍珠格子, "道具", 珍珠编号, 1) == false then
		return
	end

	玩家数据[id].角色:扣除银子(修理费用, 0, 0, "修理装备耐久", 1)

	玩家数据[id].道具.数据[装备格子].耐久 = 玩家数据[id].道具.数据[装备格子].耐久 + 500

	常规提示(id, "#Y/装备修理成功！")
	刷新道具行囊单格(id, "道具", 装备编号, 装备格子)
end

function 装备处理类:装备熔炼处理(连接id, 序号, id, 内容)
	local 格子1 = 玩家数据[id].角色.数据.道具[内容.序列]
	local 格子2 = 玩家数据[id].角色.数据.道具[内容.序列1]

	if 玩家数据[id].道具.数据[格子1] == nil or 玩家数据[id].道具.数据[格子2] == nil or 玩家数据[id].道具.数据[格子1] == nil or 玩家数据[id].道具.数据[格子2] == nil then
		道具刷新(id)

		return
	end

	if (玩家数据[id].道具.数据[格子1].名称 == "钨金" or 玩家数据[id].道具.数据[格子2].名称 == "钨金") and (玩家数据[id].道具.数据[格子1].总类 == 2 or 玩家数据[id].道具.数据[格子2].总类 == 2) then
		local 宝石格子 = 0
		local 装备格子 = 0

		if 玩家数据[id].道具.数据[格子1].总类 == 5 then
			宝石格子 = 格子1
			装备格子 = 格子2
		else
			宝石格子 = 格子2
			装备格子 = 格子1
		end

		if 玩家数据[id].道具.数据[装备格子].灵饰 then
			常规提示(id, "钨金不能镶嵌在灵饰上")

			return
		end

		if 玩家数据[id].道具.数据[装备格子].制造者 == nil then
			常规提示(id, "必须是打造出来的装备才能进行熔炼")

			return
		end

		if 玩家数据[id].道具.数据[装备格子].耐久 >= 20 then
			玩家数据[id].道具.数据[装备格子].耐久 = 玩家数据[id].道具.数据[装备格子].耐久 - 20
		else
			常规提示(id, "耐久度不足")

			return
		end

		if ygsj() <= 70 then
			if 宝石格子 == 玩家数据[id].角色.数据.道具[内容.序列] then
				玩家数据[id].角色.数据.道具[内容.序列] = nil
				玩家数据[id].道具.数据[宝石格子] = nil

				刷新道具行囊单格(id, "道具", 内容.序列, 宝石格子)
			else
				玩家数据[id].角色.数据.道具[内容.序列1] = nil
				玩家数据[id].道具.数据[宝石格子] = nil

				刷新道具行囊单格(id, "道具", 内容.序列1, 宝石格子)
			end

			常规提示(id, "装备熔炼失败")

			return
		end

		local 基础属性 = {}
		local 三围属性 = {
			"体质",
			"魔力",
			"力量",
			"耐力",
			"敏捷"
		}

		if 玩家数据[id].道具.数据[装备格子].分类 == 3 then
			table.insert(基础属性, {
				"伤害",
				math.floor(玩家数据[id].道具.数据[装备格子].伤害 / 30)
			})
			table.insert(基础属性, {
				"命中",
				math.floor(玩家数据[id].道具.数据[装备格子].命中 / 15)
			})

			for i, v in ipairs(三围属性) do
				if 玩家数据[id].道具.数据[装备格子][三围属性[i]] ~= nil then
					table.insert(基础属性, {
						三围属性[i],
						math.floor(玩家数据[id].道具.数据[装备格子][三围属性[i]] / 20)
					})
				end
			end
		elseif 玩家数据[id].道具.数据[装备格子].分类 == 1 then
			table.insert(基础属性, {
				"防御",
				math.floor(玩家数据[id].道具.数据[装备格子].防御 / 30)
			})
			table.insert(基础属性, {
				"魔法",
				math.floor(玩家数据[id].道具.数据[装备格子].魔法 / 30)
			})
		elseif 玩家数据[id].道具.数据[装备格子].分类 == 5 then
			table.insert(基础属性, {
				"防御",
				math.floor(玩家数据[id].道具.数据[装备格子].防御 / 30)
			})
			table.insert(基础属性, {
				"气血",
				math.floor(玩家数据[id].道具.数据[装备格子].气血 / 30)
			})
		elseif 玩家数据[id].道具.数据[装备格子].分类 == 2 then
			table.insert(基础属性, {
				"灵力",
				math.floor(玩家数据[id].道具.数据[装备格子].灵力 / 30)
			})
		elseif 玩家数据[id].道具.数据[装备格子].分类 == 4 then
			table.insert(基础属性, {
				"防御",
				math.floor(玩家数据[id].道具.数据[装备格子].防御 / 30)
			})

			for i, v in ipairs(三围属性) do
				if 玩家数据[id].道具.数据[装备格子][三围属性[i]] ~= nil then
					table.insert(基础属性, {
						三围属性[i],
						math.floor(玩家数据[id].道具.数据[装备格子][三围属性[i]] / 10)
					})
				end
			end
		elseif 玩家数据[id].道具.数据[装备格子].分类 == 6 then
			table.insert(基础属性, {
				"防御",
				math.floor(玩家数据[id].道具.数据[装备格子].防御 / 30)
			})
			table.insert(基础属性, {
				"敏捷",
				math.floor(玩家数据[id].道具.数据[装备格子].敏捷 / 20)
			})
		end

		if 玩家数据[id].道具.数据[装备格子].熔炼属性 == nil then
			玩家数据[id].道具.数据[装备格子].熔炼属性 = {}
		end

		local 临时 = {}

		for i = 1, #基础属性 do
			临时[i] = 基础属性[i]
			临时[i][2] = 取随机数(-临时[i][2], 临时[i][2])
		end

		if 临时[1] ~= nil and 玩家数据[id].道具.数据[装备格子].熔炼属性[1] == nil then
			玩家数据[id].道具.数据[装备格子].熔炼属性[1] = 临时[1]
		elseif 临时[1] ~= nil and 玩家数据[id].道具.数据[装备格子].熔炼属性[1] ~= nil then
			玩家数据[id].道具.数据[装备格子].熔炼属性[1][2] = 临时[1][2] + 玩家数据[id].道具.数据[装备格子].熔炼属性[1][2]
		end

		if 临时[2] ~= nil and 玩家数据[id].道具.数据[装备格子].熔炼属性[2] == nil then
			玩家数据[id].道具.数据[装备格子].熔炼属性[2] = 临时[2]
		elseif 临时[2] ~= nil and 玩家数据[id].道具.数据[装备格子].熔炼属性[2] ~= nil then
			玩家数据[id].道具.数据[装备格子].熔炼属性[2][2] = 临时[2][2] + 玩家数据[id].道具.数据[装备格子].熔炼属性[2][2]
		end

		if 临时[3] ~= nil and 玩家数据[id].道具.数据[装备格子].熔炼属性[3] == nil then
			玩家数据[id].道具.数据[装备格子].熔炼属性[3] = 临时[3]
		elseif 临时[3] ~= nil and 玩家数据[id].道具.数据[装备格子].熔炼属性[3] ~= nil then
			玩家数据[id].道具.数据[装备格子].熔炼属性[3][2] = 临时[3][2] + 玩家数据[id].道具.数据[装备格子].熔炼属性[3][2]
		end

		if 临时[4] ~= nil and 玩家数据[id].道具.数据[装备格子].熔炼属性[4] == nil then
			玩家数据[id].道具.数据[装备格子].熔炼属性[4] = 临时[4]
		elseif 临时[4] ~= nil and 玩家数据[id].道具.数据[装备格子].熔炼属性[4] ~= nil then
			玩家数据[id].道具.数据[装备格子].熔炼属性[4][2] = 临时[4][2] + 玩家数据[id].道具.数据[装备格子].熔炼属性[4][2]
		end

		if 玩家数据[id].道具.数据[装备格子].熔炼属性[1] ~= nil then
			if 玩家数据[id].道具.数据[装备格子].熔炼属性[1][2] > 0 then
				玩家数据[id].道具.数据[装备格子].熔炼属性[1][3] = "+"

				if 玩家数据[id].道具.数据[装备格子].熔炼属性[1][2] > 玩家数据[id].道具.数据[装备格子][玩家数据[id].道具.数据[装备格子].熔炼属性[1][1]] / 10 then
					玩家数据[id].道具.数据[装备格子].熔炼属性[1][2] = math.floor(玩家数据[id].道具.数据[装备格子][玩家数据[id].道具.数据[装备格子].熔炼属性[1][1]] / 20)
				end
			else
				玩家数据[id].道具.数据[装备格子].熔炼属性[1][3] = "-"

				if 玩家数据[id].道具.数据[装备格子].熔炼属性[1][2] < 玩家数据[id].道具.数据[装备格子][玩家数据[id].道具.数据[装备格子].熔炼属性[1][1]] / 10 then
					玩家数据[id].道具.数据[装备格子].熔炼属性[1][2] = math.floor(玩家数据[id].道具.数据[装备格子][玩家数据[id].道具.数据[装备格子].熔炼属性[1][1]] / 20)
				end
			end
		end

		if 玩家数据[id].道具.数据[装备格子].熔炼属性[2] ~= nil then
			if 玩家数据[id].道具.数据[装备格子].熔炼属性[2][2] > 0 then
				玩家数据[id].道具.数据[装备格子].熔炼属性[2][3] = "+"

				if 玩家数据[id].道具.数据[装备格子].熔炼属性[2][2] > 玩家数据[id].道具.数据[装备格子][玩家数据[id].道具.数据[装备格子].熔炼属性[2][1]] / 10 then
					玩家数据[id].道具.数据[装备格子].熔炼属性[2][2] = math.floor(玩家数据[id].道具.数据[装备格子][玩家数据[id].道具.数据[装备格子].熔炼属性[2][1]] / 20)
				end
			else
				玩家数据[id].道具.数据[装备格子].熔炼属性[2][3] = "-"

				if 玩家数据[id].道具.数据[装备格子].熔炼属性[2][2] < 玩家数据[id].道具.数据[装备格子][玩家数据[id].道具.数据[装备格子].熔炼属性[2][1]] / 10 then
					玩家数据[id].道具.数据[装备格子].熔炼属性[2][2] = math.floor(玩家数据[id].道具.数据[装备格子][玩家数据[id].道具.数据[装备格子].熔炼属性[2][1]] / 20)
				end
			end
		end

		if 玩家数据[id].道具.数据[装备格子].熔炼属性[3] ~= nil then
			if 玩家数据[id].道具.数据[装备格子].熔炼属性[3][2] > 0 then
				玩家数据[id].道具.数据[装备格子].熔炼属性[3][3] = "+"

				if 玩家数据[id].道具.数据[装备格子].熔炼属性[3][2] > 玩家数据[id].道具.数据[装备格子][玩家数据[id].道具.数据[装备格子].熔炼属性[3][1]] / 10 then
					玩家数据[id].道具.数据[装备格子].熔炼属性[3][2] = math.floor(玩家数据[id].道具.数据[装备格子][玩家数据[id].道具.数据[装备格子].熔炼属性[3][1]] / 20)
				end
			else
				玩家数据[id].道具.数据[装备格子].熔炼属性[3][3] = "-"

				if 玩家数据[id].道具.数据[装备格子].熔炼属性[3][2] < 玩家数据[id].道具.数据[装备格子][玩家数据[id].道具.数据[装备格子].熔炼属性[3][1]] / 10 then
					玩家数据[id].道具.数据[装备格子].熔炼属性[3][2] = math.floor(玩家数据[id].道具.数据[装备格子][玩家数据[id].道具.数据[装备格子].熔炼属性[3][1]] / 20)
				end
			end
		end

		if 玩家数据[id].道具.数据[装备格子].熔炼属性[4] ~= nil then
			if 玩家数据[id].道具.数据[装备格子].熔炼属性[4][2] > 0 then
				玩家数据[id].道具.数据[装备格子].熔炼属性[4][3] = "+"

				if 玩家数据[id].道具.数据[装备格子].熔炼属性[4][2] > 玩家数据[id].道具.数据[装备格子][玩家数据[id].道具.数据[装备格子].熔炼属性[4][1]] / 10 then
					玩家数据[id].道具.数据[装备格子].熔炼属性[4][2] = math.floor(玩家数据[id].道具.数据[装备格子][玩家数据[id].道具.数据[装备格子].熔炼属性[4][1]] / 20)
				end
			else
				玩家数据[id].道具.数据[装备格子].熔炼属性[4][3] = "-"

				if 玩家数据[id].道具.数据[装备格子].熔炼属性[4][2] < 玩家数据[id].道具.数据[装备格子][玩家数据[id].道具.数据[装备格子].熔炼属性[4][1]] / 10 then
					玩家数据[id].道具.数据[装备格子].熔炼属性[4][2] = math.floor(玩家数据[id].道具.数据[装备格子][玩家数据[id].道具.数据[装备格子].熔炼属性[4][1]] / 20)
				end
			end
		end

		if 宝石格子 == 玩家数据[id].角色.数据.道具[内容.序列] then
			玩家数据[id].角色.数据.道具[内容.序列] = nil
			玩家数据[id].道具.数据[宝石格子] = nil

			刷新道具行囊单格(id, "道具", 内容.序列, 宝石格子)
			刷新道具行囊单格(id, "道具", 内容.序列1, 装备格子)
		else
			玩家数据[id].角色.数据.道具[内容.序列1] = nil
			玩家数据[id].道具.数据[宝石格子] = nil

			刷新道具行囊单格(id, "道具", 内容.序列1, 宝石格子)
			刷新道具行囊单格(id, "道具", 内容.序列, 装备格子)
		end

		常规提示(id, "镶嵌熔炼成功")
	else
		常规提示(id, "这种宝石无法镶嵌到此类装备上")

		return
	end
end

function 装备处理类:熔炼上下限(装备)
end

扣除指定位置道具 = function(id, 格子, 包裹类型, 背包格子, 数量)
	if 包裹类型 == nil then
		包裹类型 = "道具"
	end

	if 玩家数据[id].道具.数据[格子].数量 == nil then
		玩家数据[id].道具.数据[格子].数量 = 1
	end

	if 玩家数据[id].道具.数据[格子] ~= nil and 玩家数据[id].道具.数据[格子].数量 >= (数量 or 1) then
		玩家数据[id].道具.数据[格子].数量 = (玩家数据[id].道具.数据[格子].数量 or 1) - (数量 or 1)

		if 玩家数据[id].道具.数据[格子].数量 < 1 then
			玩家数据[id].道具.数据[格子] = nil

			if 背包格子 ~= nil then
				玩家数据[id].角色.数据[包裹类型][背包格子] = nil
			end
		end

		刷新道具行囊单格(id, 包裹类型, 背包格子, 玩家数据[id].角色.数据[包裹类型][背包格子])

		return true
	end

	return false
end

镶嵌属性石 = function(id, 宝石格子, 装备格子)
	if 属性石数量 <= (玩家数据[id].道具.数据[装备格子].属性石数量 or 0) then
		常规提示(id, "#Y你的这件装备已经镶嵌了#R" .. 属性石数量 .. "颗以上的属性石、无法再镶嵌更多了！")

		return false
	end

	玩家数据[id].道具.数据[装备格子].属性石数量 = (玩家数据[id].道具.数据[装备格子].属性石数量 or 0) + 1

	if 玩家数据[id].道具.数据[宝石格子].特效 == "伤害" then
		玩家数据[id].道具.数据[装备格子].伤害 = (玩家数据[id].道具.数据[装备格子].伤害 or 0) + floor(服务端参数.属性石伤害)
	elseif 玩家数据[id].道具.数据[宝石格子].特效 == "灵力" then
		玩家数据[id].道具.数据[装备格子].灵力 = (玩家数据[id].道具.数据[装备格子].灵力 or 0) + floor(服务端参数.属性石灵力)
	elseif 玩家数据[id].道具.数据[宝石格子].特效 == "防御" then
		玩家数据[id].道具.数据[装备格子].防御 = (玩家数据[id].道具.数据[装备格子].防御 or 0) + floor(服务端参数.属性石防御)
	elseif 玩家数据[id].道具.数据[宝石格子].特效 == "速度" then
		玩家数据[id].道具.数据[装备格子].速度 = (玩家数据[id].道具.数据[装备格子].速度 or 0) + floor(服务端参数.属性石速度)
	elseif 玩家数据[id].道具.数据[宝石格子].特效 == "气血" then
		玩家数据[id].道具.数据[装备格子].气血 = (玩家数据[id].道具.数据[装备格子].气血 or 0) + floor(服务端参数.属性石气血)
	elseif 玩家数据[id].道具.数据[宝石格子].特效 == "魔法" then
		玩家数据[id].道具.数据[装备格子].魔法 = (玩家数据[id].道具.数据[装备格子].魔法 or 0) + floor(服务端参数.属性石魔法)
	elseif 玩家数据[id].道具.数据[宝石格子].特效 == "力量" then
		玩家数据[id].道具.数据[装备格子].力量 = (玩家数据[id].道具.数据[装备格子].力量 or 0) + floor(服务端参数.属性石力量)
	elseif 玩家数据[id].道具.数据[宝石格子].特效 == "魔力" then
		玩家数据[id].道具.数据[装备格子].魔力 = (玩家数据[id].道具.数据[装备格子].魔力 or 0) + floor(服务端参数.属性石魔力)
	elseif 玩家数据[id].道具.数据[宝石格子].特效 == "耐力" then
		玩家数据[id].道具.数据[装备格子].耐力 = (玩家数据[id].道具.数据[装备格子].耐力 or 0) + floor(服务端参数.属性石耐力)
	elseif 玩家数据[id].道具.数据[宝石格子].特效 == "体质" then
		玩家数据[id].道具.数据[装备格子].体质 = (玩家数据[id].道具.数据[装备格子].体质 or 0) + floor(服务端参数.属性石体质)
	elseif 玩家数据[id].道具.数据[宝石格子].特效 == "敏捷" then
		玩家数据[id].道具.数据[装备格子].敏捷 = (玩家数据[id].道具.数据[装备格子].敏捷 or 0) + floor(服务端参数.属性石敏捷)
	else
		玩家数据[id].道具.数据[装备格子].伤害 = (玩家数据[id].道具.数据[装备格子].伤害 or 0) + floor(服务端参数.属性石伤害)
	end

	return true
end

function 装备处理类:宝石镶嵌处理(连接id, 序号, id, 内容)
	local 格子1 = 玩家数据[id].角色.数据.道具[内容.序列]
	local 格子2 = 玩家数据[id].角色.数据.道具[内容.序列1]

	if 玩家数据[id].道具.数据[格子1] == nil or 玩家数据[id].道具.数据[格子2] == nil then
		道具刷新(id)

		return
	elseif self:宝宝点化检测(玩家数据[id].道具.数据[格子1].总类, 玩家数据[id].道具.数据[格子1].分类, 玩家数据[id].道具.数据[格子2].总类, 玩家数据[id].道具.数据[格子2].分类) then
		local 宝石格子 = 0
		local 装备格子 = 0

		if 玩家数据[id].道具.数据[格子1].总类 == 5 then
			宝石格子 = 格子1
			装备格子 = 格子2
		else
			宝石格子 = 格子2
			装备格子 = 格子1
		end

		if 玩家数据[id].道具.数据[宝石格子].名称 == "属性石" then
			local 打造金钱 = 100000

			if 玩家数据[id].角色.数据.银子 < 打造金钱 then
				常规提示(id, "#Y您的银子不够镶嵌的费用哦！")

				return
			end

			if 镶嵌属性石(id, 宝石格子, 装备格子) == false then
				return
			end

			if 宝石格子 == 玩家数据[id].角色.数据.道具[内容.序列] then
				扣除指定位置道具(id, 宝石格子, "道具", 内容.序列, 1)
				刷新道具行囊单格(id, "道具", 内容.序列1, 装备格子)
			else
				扣除指定位置道具(id, 宝石格子, "道具", 内容.序列1, 1)
				刷新道具行囊单格(id, "道具", 内容.序列1, 装备格子)
			end

			常规提示(id, "属性石镶嵌成功、这件装备最多还可镶嵌#G" .. 属性石数量 - 玩家数据[id].道具.数据[装备格子].属性石数量 .. "#Y颗属性石！")
			玩家数据[id].角色:扣除银子(math.abs(打造金钱), 0, 0, "镶嵌宝石", 1)
			玩家数据[id].角色:刷新信息()

			return
		end

		local 附加状态 = "附加状态"

		if 追加法术技能表[玩家数据[id].道具.数据[宝石格子].附带技能] ~= nil then
			附加状态 = "追加法术"
		end

		玩家数据[id].道具.数据[装备格子].套装效果 = {
			附加状态,
			玩家数据[id].道具.数据[宝石格子].附带技能
		}

		常规提示(id, "#Y/点化召唤兽装备成功2！")

		if 宝石格子 == 玩家数据[id].角色.数据.道具[内容.序列] then
			扣除指定位置道具(id, 宝石格子, "道具", 内容.序列, 1)
			刷新道具行囊单格(id, "道具", 内容.序列1, 装备格子)
		else
			扣除指定位置道具(id, 宝石格子, "道具", 内容.序列1, 1)
			刷新道具行囊单格(id, "道具", 内容.序列, 装备格子)
		end

		return
	end

	if (玩家数据[id].道具.数据[格子1].总类 == 5 or 玩家数据[id].道具.数据[格子2].总类 == 5) and (玩家数据[id].道具.数据[格子1].总类 == 2 or 玩家数据[id].道具.数据[格子2].总类 == 2) then
		local 宝石格子 = 0
		local 装备格子 = 0

		if 玩家数据[id].道具.数据[格子1].总类 == 5 then
			宝石格子 = 格子1
			装备格子 = 格子2
		else
			宝石格子 = 格子2
			装备格子 = 格子1
		end

		if 玩家数据[id].道具.数据[宝石格子].名称 == "属性石" then
			local 打造金钱 = 100000

			if 玩家数据[id].角色.数据.银子 < 打造金钱 then
				常规提示(id, "#Y您的银子不够镶嵌的费用哦！")

				return
			end

			if 镶嵌属性石(id, 宝石格子, 装备格子) == false then
				return
			end

			if 宝石格子 == 玩家数据[id].角色.数据.道具[内容.序列] then
				扣除指定位置道具(id, 宝石格子, "道具", 内容.序列, 1)
				刷新道具行囊单格(id, "道具", 内容.序列1, 装备格子)
			else
				扣除指定位置道具(id, 宝石格子, "道具", 内容.序列1, 1)
				刷新道具行囊单格(id, "道具", 内容.序列, 装备格子)
			end

			常规提示(id, "属性石镶嵌成功、这件装备最多还可镶嵌#G" .. 属性石数量 - 玩家数据[id].道具.数据[装备格子].属性石数量 .. "#Y颗属性石！")
			玩家数据[id].角色:扣除银子(math.abs(打造金钱), 0, 0, "镶嵌宝石", 1)
			玩家数据[id].角色:刷新信息()

			return
		end

		if 玩家数据[id].道具.数据[宝石格子].分类 ~= 6 then
			常规提示(id, "只有宝石才可以镶嵌在装备上")

			return
		end

		if 玩家数据[id].道具.数据[宝石格子].名称 == "星辉石" and 玩家数据[id].道具.数据[装备格子].灵饰 then
			if 玩家数据[id].道具.数据[装备格子].级别限制 == nil then
				玩家数据[id].道具.数据[装备格子].级别限制 = 取物品数据(玩家数据[id].道具.数据[装备格子].名称)[5]
			end

			local 特效判断 = {}

			if 玩家数据[id].道具.数据[宝石格子].特效 ~= nil then
				特效判断 = 列表模式转换(玩家数据[id].道具.数据[宝石格子].特效)
			end

			if 玩家数据[id].道具.数据[宝石格子].级别限制 - 1 ~= 玩家数据[id].道具.数据[装备格子].幻化等级 then
				常规提示(id, "该灵饰目前只能用#R/" .. 玩家数据[id].道具.数据[装备格子].幻化等级 + 1 .. "#Y/级的星辉石进行强化")

				return
			elseif 特效判断.无级别限制 == nil and 玩家数据[id].道具.数据[装备格子].幻化等级 >= 玩家数据[id].道具.数据[装备格子].级别限制 / 10 then
				常规提示(id, "#Y/灵饰强化等级不能超过装备等级")

				return
			end

			玩家数据[id].道具.数据[装备格子].幻化等级 = 玩家数据[id].道具.数据[装备格子].幻化等级 + 1

			for n = 1, #玩家数据[id].道具.数据[装备格子].幻化属性.附加 do
				玩家数据[id].道具.数据[装备格子].幻化属性.附加[n].强化 = 0
				玩家数据[id].道具.数据[装备格子].幻化属性.附加[n].强化 = math.floor(幻化属性强化[玩家数据[id].道具.数据[装备格子].幻化属性.附加[n].类型] * 玩家数据[id].道具.数据[装备格子].幻化等级)
			end

			常规提示(id, "#Y/灵饰强化成功！")

			if 宝石格子 == 玩家数据[id].角色.数据.道具[内容.序列] then
				扣除指定位置道具(id, 宝石格子, "道具", 内容.序列, 1)
				刷新道具行囊单格(id, "道具", 内容.序列1, 装备格子)
			else
				扣除指定位置道具(id, 宝石格子, "道具", 内容.序列1, 1)
				刷新道具行囊单格(id, "道具", 内容.序列, 装备格子)
			end

			return
		end

		if 玩家数据[id].道具.数据[宝石格子].名称 == "钟灵石" and 玩家数据[id].道具.数据[装备格子].灵饰 then
			if 玩家数据[id].道具.数据[装备格子].级别限制 == nil then
				玩家数据[id].道具.数据[装备格子].级别限制 = 取物品数据(玩家数据[id].道具.数据[装备格子].名称)[5]
			end

			if 玩家数据[id].道具.数据[装备格子].附加特性 == nil then
				玩家数据[id].道具.数据[装备格子].附加特性 = {}
			end

			if 玩家数据[id].道具.数据[装备格子].附加特性.幻化等级 ~= nil and 玩家数据[id].道具.数据[宝石格子].级别限制 <= 玩家数据[id].道具.数据[装备格子].附加特性.幻化等级 then
				常规提示(id, "#Y/该灵饰当前需要使用#R" .. 玩家数据[id].道具.数据[装备格子].附加特性.幻化等级 + 1 .. "#Y级以上的钟灵石进行幻化操作。")

				return
			elseif 玩家数据[id].道具.数据[装备格子].附加特性.幻化类型 ~= nil and 玩家数据[id].道具.数据[宝石格子].附加特性 ~= 玩家数据[id].道具.数据[装备格子].附加特性.幻化类型 then
				常规提示(id, "#Y/该灵饰当前需要使用#R" .. 玩家数据[id].道具.数据[装备格子].附加特性.幻化类型 .. "#Y钟灵石进行幻化操作。")

				return
			end

			if 玩家数据[id].道具.数据[装备格子].附加特性.幻化等级 == nil then
				玩家数据[id].道具.数据[装备格子].附加特性.幻化等级 = 玩家数据[id].道具.数据[宝石格子].级别限制
				玩家数据[id].道具.数据[装备格子].附加特性.幻化类型 = 玩家数据[id].道具.数据[宝石格子].附加特性
			else
				玩家数据[id].道具.数据[装备格子].附加特性.幻化等级 = 玩家数据[id].道具.数据[宝石格子].级别限制
			end

			if 宝石格子 == 玩家数据[id].角色.数据.道具[内容.序列] then
				扣除指定位置道具(id, 宝石格子, "道具", 内容.序列, 1)
				刷新道具行囊单格(id, "道具", 内容.序列1, 装备格子)
			else
				扣除指定位置道具(id, 宝石格子, "道具", 内容.序列1, 1)
				刷新道具行囊单格(id, "道具", 内容.序列, 装备格子)
			end

			常规提示(id, "#Y/灵饰幻化特性成功！")

			return
		end

		if self:取可以镶嵌(玩家数据[id].道具.数据[装备格子].分类, 玩家数据[id].道具.数据[宝石格子].子类, 玩家数据[id].道具.数据[装备格子].子类) then
			local 锻造级别 = 0

			if 玩家数据[id].道具.数据[装备格子].锻炼等级 ~= nil then
				锻造级别 = 玩家数据[id].道具.数据[装备格子].锻炼等级
			end

			锻造级别 = 锻造级别 + 1
			local 锻造级别上限 = 1

			if 玩家数据[id].道具.数据[装备格子].级别限制 ~= nil then
				锻造级别上限 = math.floor(玩家数据[id].道具.数据[装备格子].级别限制 / 10) + 1
			end

			local 特效判断 = {}

			if 玩家数据[id].道具.数据[装备格子].特效 ~= nil then
				特效判断 = 列表模式转换(玩家数据[id].道具.数据[装备格子].特效)
			end

			if 特效判断.精致 ~= nil then
				锻造级别上限 = 锻造级别上限 + 1
			end

			if 特效判断.无级别限制 ~= nil then
				锻造级别上限 = 99
			end

			if 锻造级别 > 锻造级别上限 then
				常规提示(id, "该装备已达到锻造等级上限")

				return
			end

			if 玩家数据[id].道具.数据[宝石格子].级别限制 ~= 锻造级别 then
				常规提示(id, "该装备目前只能用#R/" .. 锻造级别 .. "#Y/级宝石镶嵌")

				return
			end

			if 玩家数据[id].道具.数据[装备格子].镶嵌宝石 == nil then
				玩家数据[id].道具.数据[装备格子].镶嵌宝石 = {}
				玩家数据[id].道具.数据[装备格子].镶嵌类型 = {}
			end

			if 玩家数据[id].道具.数据[装备格子].镶嵌宝石[1] == nil then
				玩家数据[id].道具.数据[装备格子].镶嵌宝石[1] = 玩家数据[id].道具.数据[宝石格子].名称
			elseif 玩家数据[id].道具.数据[装备格子].镶嵌宝石[2] == nil and 玩家数据[id].道具.数据[装备格子].镶嵌宝石[1] ~= 玩家数据[id].道具.数据[宝石格子].名称 then
				玩家数据[id].道具.数据[装备格子].镶嵌宝石[2] = 玩家数据[id].道具.数据[宝石格子].名称
			elseif 玩家数据[id].道具.数据[装备格子].镶嵌宝石[1] ~= 玩家数据[id].道具.数据[宝石格子].名称 and 玩家数据[id].道具.数据[装备格子].镶嵌宝石[2] ~= 玩家数据[id].道具.数据[宝石格子].名称 then
				常规提示(id, "装备最多只能镶嵌两种不同类型的宝石")

				return
			end

			玩家数据[id].道具.数据[装备格子].锻炼等级 = 锻造级别
			玩家数据[id].道具.数据[装备格子].镶嵌类型[锻造级别] = 玩家数据[id].道具.数据[宝石格子].名称

			if 玩家数据[id].道具.数据[宝石格子].子类 == 1 then
				玩家数据[id].道具.数据[装备格子].气血 = (玩家数据[id].道具.数据[装备格子].气血 or 0) - floor(40 * (玩家数据[id].道具.数据[宝石格子].级别限制 - 1))
				玩家数据[id].道具.数据[装备格子].气血 = (玩家数据[id].道具.数据[装备格子].气血 or 0) + floor(40 * 玩家数据[id].道具.数据[宝石格子].级别限制)
			elseif 玩家数据[id].道具.数据[宝石格子].子类 == 2 then
				玩家数据[id].道具.数据[装备格子].防御 = (玩家数据[id].道具.数据[装备格子].防御 or 0) - floor(12 * (玩家数据[id].道具.数据[宝石格子].级别限制 - 1))
				玩家数据[id].道具.数据[装备格子].防御 = (玩家数据[id].道具.数据[装备格子].防御 or 0) + floor(12 * 玩家数据[id].道具.数据[宝石格子].级别限制)
			elseif 玩家数据[id].道具.数据[宝石格子].子类 == 3 then
				玩家数据[id].道具.数据[装备格子].伤害 = (玩家数据[id].道具.数据[装备格子].伤害 or 0) - floor(8 * (玩家数据[id].道具.数据[宝石格子].级别限制 - 1))
				玩家数据[id].道具.数据[装备格子].伤害 = (玩家数据[id].道具.数据[装备格子].伤害 or 0) + floor(8 * 玩家数据[id].道具.数据[宝石格子].级别限制)
			elseif 玩家数据[id].道具.数据[宝石格子].子类 == 4 then
				玩家数据[id].道具.数据[装备格子].灵力 = (玩家数据[id].道具.数据[装备格子].灵力 or 0) - floor(6 * (玩家数据[id].道具.数据[宝石格子].级别限制 - 1))
				玩家数据[id].道具.数据[装备格子].灵力 = (玩家数据[id].道具.数据[装备格子].灵力 or 0) + floor(6 * 玩家数据[id].道具.数据[宝石格子].级别限制)
			elseif 玩家数据[id].道具.数据[宝石格子].子类 == 5 then
				玩家数据[id].道具.数据[装备格子].命中 = (玩家数据[id].道具.数据[装备格子].命中 or 0) - floor(25 * (玩家数据[id].道具.数据[宝石格子].级别限制 - 1))
				玩家数据[id].道具.数据[装备格子].命中 = (玩家数据[id].道具.数据[装备格子].命中 or 0) + floor(25 * 玩家数据[id].道具.数据[宝石格子].级别限制)
			elseif 玩家数据[id].道具.数据[宝石格子].子类 == 6 then
				玩家数据[id].道具.数据[装备格子].速度 = (玩家数据[id].道具.数据[装备格子].速度 or 0) - floor(8 * (玩家数据[id].道具.数据[宝石格子].级别限制 - 1))
				玩家数据[id].道具.数据[装备格子].速度 = (玩家数据[id].道具.数据[装备格子].速度 or 0) + floor(8 * 玩家数据[id].道具.数据[宝石格子].级别限制)
			elseif 玩家数据[id].道具.数据[宝石格子].子类 == 7 then
				玩家数据[id].道具.数据[装备格子].气血回复效果 = (玩家数据[id].道具.数据[装备格子].气血回复效果 or 0) - floor(12 * (玩家数据[id].道具.数据[宝石格子].级别限制 - 1))
				玩家数据[id].道具.数据[装备格子].气血回复效果 = (玩家数据[id].道具.数据[装备格子].气血回复效果 or 0) + floor(12 * 玩家数据[id].道具.数据[宝石格子].级别限制)
			elseif 玩家数据[id].道具.数据[宝石格子].子类 == 1001 then
				玩家数据[id].道具.数据[装备格子].治疗能力 = (玩家数据[id].道具.数据[装备格子].治疗能力 or 0) - floor(8 * (玩家数据[id].道具.数据[宝石格子].级别限制 - 1))
				玩家数据[id].道具.数据[装备格子].治疗能力 = (玩家数据[id].道具.数据[装备格子].治疗能力 or 0) + floor(8 * 玩家数据[id].道具.数据[宝石格子].级别限制)
			end

			if 宝石格子 == 玩家数据[id].角色.数据.道具[内容.序列] then
				扣除指定位置道具(id, 宝石格子, "道具", 内容.序列, 1)
				刷新道具行囊单格(id, "道具", 内容.序列1, 装备格子)
			else
				扣除指定位置道具(id, 宝石格子, "道具", 内容.序列1, 1)
				刷新道具行囊单格(id, "道具", 内容.序列, 装备格子)
			end

			常规提示(id, "镶嵌装备成功")
		else
			常规提示(id, "这种宝石无法镶嵌到此类装备上")

			return
		end
	end
end

function 装备处理类:宝宝点化检测(总类1, 分类1, 总类2, 分类2)
	if 总类1 == 2 and (分类1 == 7 or 分类1 == 8 or 分类1 == 9) and 总类2 == 5 and 分类2 == 5 then
		return true
	elseif 总类2 == 2 and (分类2 == 7 or 分类2 == 8 or 分类2 == 9) and 总类1 == 5 and 分类1 == 5 then
		return true
	else
		return false
	end
end

打造金钱公式 = function(a)
	if a <= 40 then
		return floor(a * 100 + 2000)
	elseif a > 40 and a <= 90 then
		return floor((a - 50) * 1000 + 10000)
	elseif a >= 100 then
		return floor((a - 100) * 10000 + 100000)
	end
end

打造体力公式 = function(a)
	return math.min(30 + 2 * a, 330)
end

角色扣除体力 = function(id, 扣除体力)
	if 玩家数据[id].角色.数据.体力 < 扣除体力 then
		常规提示(id, "#Y你的体力不足#R" .. 扣除体力)

		return false
	else
		玩家数据[id].角色.数据.体力 = 玩家数据[id].角色.数据.体力 - 扣除体力

		常规提示(id, "#Y你消耗了#R" .. 扣除体力 .. "#Y体力")

		return true
	end
end

打造符处理 = function(id, 类型, 书铁等级)
	local 背包道具 = 玩家数据[id].角色.数据.道具
	local 道具数据 = 玩家数据[id].道具.数据
	local 返回 = 0
	local 等级判断 = 10000

	for i = 1, 100 do
		local n = 背包道具[i]

		if 背包道具[i] ~= nil and 道具数据[n].名称 == 类型 and 书铁等级 <= 道具数据[n].级别限制 then
			if 道具数据[n].级别限制 == 书铁等级 then
				返回 = i

				break
			elseif 道具数据[n].级别限制 < 等级判断 then
				返回 = i
				等级判断 = 道具数据[n].级别限制 + 0
			end
		end
	end

	return 返回
end

熟练度影响计算 = function(属性下限, 属性上限, 熟练度)
	local 熟练度影响 = 取熟练度加成(熟练度, "保下限")
	属性下限 = qz1(属性下限 + (属性上限 - 属性下限) * 熟练度影响)

	return 取随机数(属性下限, 属性上限)
end

function 装备处理类:打造类型处理(连接id, 序号, id, 内容)
	local 行囊格子 = 玩家数据[id].角色:取道具格子()

	if 行囊格子 == 0 then
		常规提示(id, "您的道具栏物品已经满啦")

		return
	end

	local 格子1 = 玩家数据[id].角色.数据.道具[内容.序列]
	local 格子2 = 玩家数据[id].角色.数据.道具[内容.序列1]

	if 玩家数据[id].道具.数据[格子1] == nil or 玩家数据[id].道具.数据[格子2] == nil then
		道具刷新(id)

		return
	end

	if 玩家数据[id].道具.数据[格子1].总类 == 5 and (玩家数据[id].道具.数据[格子1].分类 == 20 or 玩家数据[id].道具.数据[格子1].分类 == 21) and 玩家数据[id].道具.数据[格子2].总类 == 5 and (玩家数据[id].道具.数据[格子2].分类 == 21 or 玩家数据[id].道具.数据[格子2].分类 == 20) then
		local 制造格子 = 0
		local 精铁格子 = 0

		if 玩家数据[id].道具.数据[格子1].名称 == "灵饰指南书" and 玩家数据[id].道具.数据[格子2].名称 == "元灵晶石" then
			制造格子 = 格子1
			精铁格子 = 格子2
		elseif 玩家数据[id].道具.数据[格子1].名称 == "元灵晶石" and 玩家数据[id].道具.数据[格子2].名称 == "灵饰指南书" then
			制造格子 = 格子2
			精铁格子 = 格子1
		end

		if 制造格子 == 0 or 精铁格子 == 0 then
			常规提示(id, "打造装备需要使用灵饰指南书和元灵晶石，你这给我的是啥玩意？？？")

			return
		elseif 玩家数据[id].道具.数据[精铁格子].子类 < 玩家数据[id].道具.数据[制造格子].子类 then
			常规提示(id, "你的这块元灵晶石等级太低了，配不上这本制造指南书")

			return
		elseif 玩家数据[id].道具.数据[制造格子].子类 % 20 ~= 0 then
			常规提示(id, "无法打造这个级别的灵饰。")

			return
		end

		local 打造符 = 0
		满足打造等级 = 玩家数据[id].角色.数据.辅助技能[角色辅助技能列表1.打造技巧].等级 + 打造技能高于等级
		打造符 = 打造符处理(id, "打造符", 玩家数据[id].道具.数据[制造格子].子类)
		local 扣除金钱 = 打造金钱公式(玩家数据[id].道具.数据[制造格子].子类)
		local 扣除体力 = 打造体力公式(玩家数据[id].道具.数据[制造格子].子类)

		if 取银子(id) < 扣除金钱 then
			常规提示(id, "#Y你银子不够打造装备哦！")

			return
		elseif 玩家数据[id].角色.数据.体力 < 扣除体力 and 打造符 == 0 then
			常规提示(id, "#Y你的体力不足#R" .. 扣除体力)

			return
		end

		if 打造符 == 0 then
			角色扣除体力(id, 扣除体力)
		end

		玩家数据[id].角色:扣除银子(math.abs(扣除金钱), 0, 0, "打造灵饰", 1)

		local 打造熟练度 = 0
		local 临时名称 = 制造装备[玩家数据[id].道具.数据[制造格子].特效][玩家数据[id].道具.数据[制造格子].子类]

		if 玩家数据[id].打造方式 == 1 then
			local 道具 = 物品类()

			道具:置对象(临时名称)

			道具.级别限制 = 玩家数据[id].道具.数据[制造格子].子类
			道具.幻化等级 = 0
			local 临时等级 = 玩家数据[id].道具.数据[制造格子].子类
			local 临时类型 = 玩家数据[id].道具.数据[制造格子].特效
			local 新格子 = 玩家数据[id].道具:取新编号()
			玩家数据[id].角色.数据.道具[行囊格子] = 新格子
			玩家数据[id].道具.数据[新格子] = nil
			玩家数据[id].道具.数据[新格子] = 道具
			打造熟练度 = 扣除打造符处理(id, 打造符, 普通打造熟练度)

			if 打造符 ~= 0 then
				常规提示(id, "你使用了制造符打造灵饰。")
			end

			玩家数据[id].道具:灵饰处理(id, 新格子, 临时等级, 0, 临时类型, 打造熟练度)

			玩家数据[id].道具.数据[新格子].耐久 = 500
			玩家数据[id].道具.数据[新格子].部位类型 = 临时类型
			道具.制造者 = 打造符主人 or 玩家数据[id].角色.数据.名称
			道具.灵饰 = true

			刷新道具行囊单格(id, "道具", 行囊格子, 新格子)
			扣除背包位置道具(id, 内容.序列, 1)
			扣除背包位置道具(id, 内容.序列1, 1)
			常规提示(id, "制造灵饰成功")
		else
			打造熟练度 = 扣除打造符处理(id, 打造符, 强化打造熟练度)

			if 打造符 ~= 0 then
				常规提示(id, "你使用了制造符强化打造灵饰。")
			end

			任务处理类:设置打造灵饰任务(id, 临时名称, 玩家数据[id].道具.数据[制造格子].子类, 玩家数据[id].道具.数据[制造格子].特效, 打造符主人, 打造熟练度)
			扣除背包位置道具(id, 内容.序列, 1)
			扣除背包位置道具(id, 内容.序列1, 1)
		end
	elseif 玩家数据[id].道具.数据[格子1].总类 == 5 and (玩家数据[id].道具.数据[格子1].分类 == 1 or 玩家数据[id].道具.数据[格子1].分类 == 2) and 玩家数据[id].道具.数据[格子2].总类 == 5 and (玩家数据[id].道具.数据[格子2].分类 == 1 or 玩家数据[id].道具.数据[格子2].分类 == 2) then
		local 制造格子 = 0
		local 精铁格子 = 0

		if 玩家数据[id].道具.数据[格子1].名称 == "制造指南书" and 玩家数据[id].道具.数据[格子2].名称 == "百炼精铁" then
			制造格子 = 格子1
			精铁格子 = 格子2
		elseif 玩家数据[id].道具.数据[格子2].名称 == "制造指南书" and 玩家数据[id].道具.数据[格子1].名称 == "百炼精铁" then
			制造格子 = 格子2
			精铁格子 = 格子1
		end

		if 制造格子 == 0 or 精铁格子 == 0 then
			常规提示(id, "打造装备需要使用制造指南书和百炼精铁，你这给我的是啥玩意？？？")

			return
		end

		if 玩家数据[id].道具.数据[精铁格子].子类 < 玩家数据[id].道具.数据[制造格子].子类 then
			常规提示(id, "你的这块精铁等级太低了，配不上这本制造指南书")

			return
		end

		local 临时序列 = 玩家数据[id].道具.数据[制造格子].特效

		if 临时序列 == 25 then
			临时序列 = 23
		elseif 临时序列 == 24 then
			临时序列 = 22
		elseif 临时序列 == 23 or 临时序列 == 22 then
			临时序列 = 21
		elseif 临时序列 == 21 then
			临时序列 = 20
		elseif 临时序列 == 20 or 临时序列 == 19 then
			临时序列 = 19
		end

		local 临时等级 = 玩家数据[id].道具.数据[制造格子].子类 / 10

		if 临时序列 <= 18 and 临时等级 >= 9 then
			if 临时等级 <= 11 then
				临时等级 = 取随机数(9, 11)
			elseif 临时等级 <= 14 then
				临时等级 = 取随机数(12, 14)
			end

			临时等级 = 临时等级 + 1
		else
			临时等级 = 临时等级 + 1
		end

		local 临时类型 = self.打造物品[临时序列][临时等级]

		if type(临时类型) == "table" then
			if 玩家数据[id].道具.数据[制造格子].特效 == 23 then
				临时类型 = 临时类型[2]
			elseif 玩家数据[id].道具.数据[制造格子].特效 == 22 then
				临时类型 = 临时类型[1]
			elseif 玩家数据[id].道具.数据[制造格子].特效 == 20 then
				临时类型 = 临时类型[2]
			elseif 玩家数据[id].道具.数据[制造格子].特效 == 19 then
				临时类型 = 临时类型[1]
			else
				临时类型 = 临时类型[取随机数(1, 2)]
			end
		end

		local 道具 = 物品类()

		道具:置对象(临时类型)

		local 满足打造等级 = 0
		local 满足打造条件 = true
		local 满足裁缝条件 = true
		local 满足炼金条件 = true
		local 打造符 = 0

		if 打造熟练度开关 ~= 0 then
			for n = 1, #玩家数据[id].角色.数据.辅助技能 do
				if 玩家数据[id].角色.数据.辅助技能[n].名称 == "打造技巧" and 玩家数据[id].道具.数据[格子1].总类 == 5 and 道具.分类 == 3 then
					满足打造等级 = 玩家数据[id].角色.数据.辅助技能[n].等级 + 打造技能高于等级
					打造符 = 打造符处理(id, "打造符", 玩家数据[id].道具.数据[制造格子].子类)
				elseif 玩家数据[id].角色.数据.辅助技能[n].名称 == "裁缝技巧" and 玩家数据[id].道具.数据[格子1].总类 == 5 and (道具.分类 == 4 or 道具.分类 == 1) then
					满足打造等级 = 玩家数据[id].角色.数据.辅助技能[n].等级 + 打造技能高于等级
					打造符 = 打造符处理(id, "裁缝符", 玩家数据[id].道具.数据[制造格子].子类)
				elseif 玩家数据[id].角色.数据.辅助技能[n].名称 == "炼金术" and 玩家数据[id].道具.数据[格子1].总类 == 5 and (道具.分类 == 2 or 道具.分类 == 5 or 道具.分类 == 6) then
					满足打造等级 = 玩家数据[id].角色.数据.辅助技能[n].等级 + 打造技能高于等级
					打造符 = 打造符处理(id, "炼金符", 玩家数据[id].道具.数据[制造格子].子类)
				end
			end

			if 满足打造等级 < 玩家数据[id].道具.数据[制造格子].子类 and 打造符 == 0 then
				满足打造条件 = false
			end

			if 满足打造等级 < 玩家数据[id].道具.数据[制造格子].子类 and 打造符 == 0 then
				满足裁缝条件 = false
			end

			if 满足打造等级 < 玩家数据[id].道具.数据[制造格子].子类 and 打造符 == 0 then
				满足炼金条件 = false
			end

			if 玩家数据[id].道具.数据[格子1].总类 == 5 and 道具.分类 == 3 and 满足打造条件 == false then
				常规提示(id, "你的打造技巧等级不够，无法制作该装备")

				return
			end

			if 玩家数据[id].道具.数据[格子1].总类 == 5 and (道具.分类 == 4 or 道具.分类 == 1) and 满足裁缝条件 == false then
				常规提示(id, "你的裁缝技巧等级不够，无法制作该装备")

				return
			end

			if 玩家数据[id].道具.数据[格子1].总类 == 5 and (道具.分类 == 2 or 道具.分类 == 5 or 道具.分类 == 6) and 满足炼金条件 == false then
				常规提示(id, "你的炼金术等级不够，无法制作该装备")

				return
			end
		end

		local 扣除金钱 = 打造金钱公式(玩家数据[id].道具.数据[制造格子].子类)
		local 扣除体力 = 打造体力公式(玩家数据[id].道具.数据[制造格子].子类)

		if 取银子(id) < 扣除金钱 then
			常规提示(id, "#Y你银子不够打造装备哦！")

			return
		elseif 玩家数据[id].角色.数据.体力 < 扣除体力 and 打造符 == 0 then
			常规提示(id, "#Y你的体力不足#R" .. 扣除体力)

			return
		end

		玩家数据[id].角色:扣除银子(math.abs(扣除金钱), 0, 0, "打造装备", 1)

		if 打造符 == 0 then
			角色扣除体力(id, 扣除体力)
		end

		local 打造熟练度 = 0

		if 玩家数据[id].打造方式 == 1 then
			道具.级别限制 = 玩家数据[id].道具.数据[制造格子].子类
			local dz = self:打造公式(id, 玩家数据[id].道具.数据[制造格子].子类, 临时序列, 打造熟练度)

			if dz[1] ~= nil then
				道具.命中 = dz[1]
			end

			if dz[2] ~= nil then
				道具.伤害 = dz[2]
			end

			if dz[3] ~= nil then
				道具.防御 = dz[3]
			end

			if dz[4] ~= nil then
				道具.魔法 = dz[4]
			end

			if dz[5] ~= nil then
				道具.灵力 = dz[5]
			end

			if dz[6] ~= nil then
				道具.气血 = dz[6]
			end

			if dz[7] ~= nil then
				道具.敏捷 = dz[7]
			end

			if dz[8] ~= nil then
				道具.体质 = dz[8]
			end

			if dz[9] ~= nil then
				道具.力量 = dz[9]
			end

			if dz[10] ~= nil then
				道具.耐力 = dz[10]
			end

			if dz[11] ~= nil then
				道具.魔力 = dz[11]
			end

			if dz[12] ~= nil then
				道具 = 添加装备特效(道具)
			end

			if 祝福特效[id] == true then
				if 道具.新特效 == nil then
					道具.新特效 = {
						"祝福"
					}
				else
					table.insert(道具.新特效, "祝福")
				end

				祝福特效[id] = false
			end

			if dz[13] ~= nil then
				道具.特技 = 通用特技[取随机数(1, #通用特技)]
			end

			道具.制造者 = 打造符主人 or 玩家数据[id].角色.数据.名称
			local 新格子 = 玩家数据[id].道具:取新编号()
			玩家数据[id].角色.数据.道具[行囊格子] = 新格子
			玩家数据[id].道具.数据[新格子] = nil
			玩家数据[id].道具.数据[新格子] = 道具

			if 玩家数据[id].道具.数据[新格子].级别限制 > 0 then
				玩家数据[id].道具.数据[新格子].鉴定 = false
			end

			打造熟练度 = 扣除打造符处理(id, 打造符, 普通打造熟练度)

			if 打造符 ~= 0 then
				常规提示(id, "你使用了制造符打造装备。")
			end

			玩家数据[id].道具.数据[新格子].超级五行 = 取超级五行处理(道具.级别限制, 5, 打造熟练度)
			玩家数据[id].道具.数据[新格子].五行 = 玩家数据[id].道具.数据[新格子].类型 or 取五行()

			if 玩家数据[id].道具.数据[新格子].超级五行.类型 ~= nil then
				常规提示(id, "#Y/你得到了一件#R/超级五行#Y装备。")
			end

			玩家数据[id].道具.数据[新格子].耐久 = 500
			玩家数据[id].道具.数据[新格子].识别码 = id .. "_" .. os.time() .. "_" .. 取随机数(1000, 9999999) .. "_" .. 随机序列
			随机序列 = 随机序列 + 1

			刷新道具行囊单格(id, "道具", 行囊格子, 新格子)
			扣除背包位置道具(id, 内容.序列, 1)
			扣除背包位置道具(id, 内容.序列1, 1)
			常规提示(id, "制造装备成功3")
		else
			打造熟练度 = 扣除打造符处理(id, 打造符, 强化打造熟练度)

			if 打造符 ~= 0 then
				常规提示(id, "你使用了制造符强化打造装备。")
			end

			if 玩家数据[id].打造方式 == 3 then
				任务处理类:设置打造装备任务(id, 临时类型, 玩家数据[id].道具.数据[制造格子].子类, 临时序列, 1, 打造符主人, 打造熟练度)
			else
				任务处理类:设置打造装备任务(id, 临时类型, 玩家数据[id].道具.数据[制造格子].子类, 临时序列, nil, 打造符主人, 打造熟练度)
			end

			扣除背包位置道具(id, 内容.序列, 1)
			扣除背包位置道具(id, 内容.序列1, 1)
		end
	elseif 玩家数据[id].道具.数据[格子1].总类 == 3 and 玩家数据[id].道具.数据[格子2].总类 == 3 then
		if 玩家数据[id].打造方式 == 2 then
			常规提示(id, "#Y/召唤兽装备尚未开放强化打造 暂时关闭 等待调整")

			return 0
		end

		if 玩家数据[id].道具.数据[格子1].分类 ~= 10 or 玩家数据[id].道具.数据[格子2].分类 ~= 11 then
			if 玩家数据[id].道具.数据[格子2].分类 ~= 10 or 玩家数据[id].道具.数据[格子1].分类 ~= 11 then
				常规提示(id, "#Y/制造召唤兽装备的材料需要天眼石和上古锻造图策")

				return 0
			end
		end

		local 石头格子 = 0
		local 书铁格子 = 0

		if 玩家数据[id].道具.数据[格子1].分类 == 10 then
			书铁格子 = 格子1
			石头格子 = 格子2
		else
			书铁格子 = 格子2
			石头格子 = 格子1
		end

		if 玩家数据[id].道具.数据[石头格子].级别限制 < 玩家数据[id].道具.数据[书铁格子].级别限制 then
			常规提示(id, "上古锻造图策的等级不能高过天眼石的等级")

			return 0
		end

		local 类型序列 = 0

		if 玩家数据[id].道具.数据[书铁格子].种类 == "护腕" then
			类型序列 = 24
		elseif 玩家数据[id].道具.数据[书铁格子].种类 == "项圈" then
			类型序列 = 25
		elseif 玩家数据[id].道具.数据[书铁格子].种类 == "铠甲" then
			类型序列 = 26
		end

		local 满足打造等级 = 0
		local 满足打造条件 = true

		for n = 1, #玩家数据[id].角色.数据.辅助技能 do
			if 玩家数据[id].角色.数据.辅助技能[n].名称 == "打造技巧" then
				满足打造等级 = 玩家数据[id].角色.数据.辅助技能[n].等级 + 打造技能高于等级
				打造符 = 打造符处理(id, "打造符", 玩家数据[id].道具.数据[书铁格子].级别限制)
			end
		end

		if 满足打造等级 < 玩家数据[id].道具.数据[书铁格子].级别限制 and 打造符 == 0 then
			满足打造条件 = false
		end

		if 满足打造条件 == false then
			常规提示(id, "你的打造技巧等级不够，无法打造该召唤兽装备")

			return
		end

		local 扣除金钱 = 打造金钱公式(玩家数据[id].道具.数据[书铁格子].级别限制)
		local 扣除体力 = 打造体力公式(玩家数据[id].道具.数据[书铁格子].级别限制)

		if 取银子(id) < 扣除金钱 then
			常规提示(id, "#Y你银子不够打造装备哦！")

			return
		elseif 玩家数据[id].角色.数据.体力 < 扣除体力 and 打造符 == 0 then
			常规提示(id, "#Y你的体力不足#R" .. 扣除体力)

			return
		end

		玩家数据[id].角色:扣除银子(math.abs(扣除金钱), 0, 0, "打造召唤兽装备", 1)

		if 打造符 == 0 then
			角色扣除体力(id, 扣除体力)
		end

		local 打造熟练度 = 0
		打造熟练度 = 扣除打造符处理(id, 打造符, 普通打造熟练度)

		if 打造符 ~= 0 then
			常规提示(id, "你使用了制造符打造召唤兽装备。")
		end

		local 临时序列 = math.floor((玩家数据[id].道具.数据[书铁格子].级别限制 + 5) / 10)
		local 临时名称 = self.打造物品[类型序列][临时序列]
		local 道具 = 物品类()

		道具:置对象(临时名称)

		道具.级别限制 = 玩家数据[id].道具.数据[书铁格子].级别限制
		local 熟练度 = 打造熟练度
		local 灵气 = 玩家数据[id].道具.数据[石头格子].灵气

		if 灵气 == nil then
			灵气 = 取随机数(20, 110)
		end

		local 等级 = nil

		if 取随机数(1, 10000) <= (祝福特效概率 + 取熟练度加成(熟练度, "祝福")) * 100 then
			祝福特效[id] = true
			等级 = 道具.级别限制 + 10
		else
			祝福特效[id] = false
			等级 = 道具.级别限制 + 0
		end

		local 附加概率 = 5
		local 额外加成 = 1

		if 玩家数据[id].道具.数据[石头格子].名称 == "三眼天珠" then
			附加概率 = 附加概率 + 5
			额外加成 = 1.05
			道具.制造者 = 玩家数据[id].角色.数据.名称 .. " 三眼天珠打造"
		elseif 玩家数据[id].道具.数据[石头格子].名称 == "九眼天珠" then
			附加概率 = 附加概率 + 10
			额外加成 = 1.1
			道具.制造者 = 玩家数据[id].角色.数据.名称 .. " 九眼天珠打造"
		end

		道具.耐久 = math.floor(熟练度影响计算(500, 700, 熟练度) * 额外加成)

		if 玩家数据[id].道具.数据[书铁格子].种类 == "护腕" then
			道具.防御 = math.floor((熟练度影响计算(等级 * 0.4, 等级 * 0.8 + 10, 熟练度) + 熟练度影响计算(灵气 * 0.25, 灵气 * 0.4, 熟练度)) * 额外加成)

			if ygsj(100) <= 50 then
				道具.灵力 = math.floor((熟练度影响计算(等级 * 0.2 + 6, 等级 * 0.4 + 6, 熟练度) + 熟练度影响计算(灵气 * 0.1, 灵气 * 0.2, 熟练度)) * 额外加成)
			else
				道具.伤害 = math.floor((熟练度影响计算(等级 * 0.3 + 10, 等级 * 0.6 + 10, 熟练度) + 熟练度影响计算(灵气 * 0.15, 灵气 * 0.3, 熟练度)) * 额外加成)
			end
		elseif 玩家数据[id].道具.数据[书铁格子].种类 == "项圈" then
			道具.速度 = math.floor((熟练度影响计算(等级 * 0.2 + 5, 等级 * 0.4 + 10, 熟练度) + 熟练度影响计算(灵气 * 0.1, 灵气 * 0.2, 熟练度)) * 额外加成)

			if ygsj(100) <= 50 then
				道具.灵力 = math.floor((熟练度影响计算(等级 * 0.2 + 6, 等级 * 0.4 + 6, 熟练度) + 熟练度影响计算(灵气 * 0.1, 灵气 * 0.2, 熟练度)) * 额外加成)
			else
				道具.伤害 = math.floor((熟练度影响计算(等级 * 0.3 + 10, 等级 * 0.6 + 10, 熟练度) + 熟练度影响计算(灵气 * 0.15, 灵气 * 0.3, 熟练度)) * 额外加成)
			end
		else
			道具.防御 = math.floor((熟练度影响计算(等级 * 0.4, 等级 * 0.8 + 10, 熟练度) + 熟练度影响计算(灵气 * 0.25, 灵气 * 0.4, 熟练度)) * 额外加成)
			道具.气血 = math.floor((熟练度影响计算(等级 * 0.65 + 20, 等级 * 1.05 + 30, 熟练度) + 熟练度影响计算(灵气 * 0.45, 灵气 * 0.95, 熟练度)) * 额外加成)
		end

		local 附加范围 = {
			"伤害",
			"灵力",
			"敏捷",
			"耐力",
			"体质",
			"力量",
			"魔力",
			"气血",
			"魔法",
			"速度"
		}

		for n = 1, 10 do
			local 类型 = 附加范围[n]

			if ygsj() <= 附加概率 and 道具[类型] == nil then
				if 类型 == "伤害" then
					道具[类型] = math.floor((熟练度影响计算(等级 * 0.3 + 10, 等级 * 0.6 + 10, 熟练度) + 熟练度影响计算(灵气 * 0.15, 灵气 * 0.3, 熟练度)) * 额外加成)
				elseif 类型 == "灵力" then
					道具[类型] = math.floor((熟练度影响计算(等级 * 0.2 + 6, 等级 * 0.4 + 6, 熟练度) + 熟练度影响计算(灵气 * 0.1, 灵气 * 0.2, 熟练度)) * 额外加成)
				elseif 类型 == "敏捷" or 类型 == "体质" or 类型 == "力量" or 类型 == "耐力" or 类型 == "魔力" then
					道具[类型] = math.floor((熟练度影响计算(等级 / 10 + 2, 等级 / 10 + 10, 熟练度) + 熟练度影响计算(灵气 / 20, 灵气 / 10, 熟练度)) * 额外加成)
				elseif 类型 == "速度" then
					道具[类型] = math.floor((熟练度影响计算(等级 * 0.2 + 5, 等级 * 0.4 + 10, 熟练度) + 熟练度影响计算(灵气 * 0.1, 灵气 * 0.2, 熟练度)) * 额外加成)
				elseif 类型 == "气血" then
					道具[类型] = math.floor((熟练度影响计算(等级 * 0.65 + 20, 等级 * 1.05 + 30, 熟练度) + 熟练度影响计算(灵气 * 0.45, 灵气 * 0.95, 熟练度)) * 额外加成)
				elseif 类型 == "魔法" then
					道具[类型] = math.floor((熟练度影响计算(等级 * 0.65 + 20, 等级 * 1.05 + 30, 熟练度) + 熟练度影响计算(灵气 * 0.45, 灵气 * 0.95, 熟练度)) * 额外加成)
				end
			end
		end

		local 特效 = {
			"无级别限制",
			"超级简易",
			"简易",
			"永不磨损"
		}

		if 取随机数(1, 10000) <= (10 + 取熟练度加成(熟练度, "特效")) * 100 then
			local 特效种类 = ygsj(#特效)
			道具.特效 = {
				特效[特效种类]
			}

			if 取随机数(1, 10000) <= (10 + 取熟练度加成(熟练度, "特效")) * 100 then
				if 特效种类 > 3 then
					特效种类 = ygsj(3)
					道具.特效[#道具.特效 + 1] = 特效[特效种类]
				else
					道具.特效[#道具.特效 + 1] = 特效[4]
				end
			end
		end

		if 祝福特效[id] == true then
			if 道具.新特效 == nil then
				道具.新特效 = {
					"祝福"
				}
			else
				table.insert(道具.新特效, "祝福")
			end

			祝福特效[id] = false

			常规提示(id, "#Y/恭喜你得到了一件#R/祝福#Y召唤兽装备。")
		end

		if 道具.制造者 == nil then
			道具.制造者 = 玩家数据[id].角色.数据.名称
		end

		local 新格子 = 玩家数据[id].道具:取新编号()
		玩家数据[id].角色.数据.道具[行囊格子] = 新格子
		玩家数据[id].道具.数据[新格子] = 道具
		玩家数据[id].道具.数据[新格子].超级五行 = 取超级五行处理(道具.级别限制, 3, 熟练度)
		玩家数据[id].道具.数据[新格子].五行 = 玩家数据[id].道具.数据[新格子].类型 or 取五行()

		if 玩家数据[id].道具.数据[新格子].超级五行.类型 ~= nil then
			常规提示(id, "#Y/你得到了一件#R/超级五行#Y召唤兽装备。")
		end

		刷新道具行囊单格(id, "道具", 行囊格子, 新格子)
		扣除背包位置道具(id, 内容.序列, 1)
		扣除背包位置道具(id, 内容.序列1, 1)
		常规提示(id, "制造召唤兽装备成功")
	end
end

function 装备处理类:装备熔合处理(连接id, 序号, id, 内容)
	if 玩家数据[id].角色:取任务(7758) ~= 0 then
		常规提示(id, "请完成当前的任务再来吧")

		return
	end

	local 格子1 = 玩家数据[id].角色.数据.道具[内容.序列]
	local 格子2 = 玩家数据[id].角色.数据.道具[内容.序列1]
	local 格子3 = 0

	if 内容.序列2 ~= nil then
		格子3 = 玩家数据[id].角色.数据.道具[内容.序列2]
	end

	if 玩家数据[id].道具.数据[格子1] == nil or 玩家数据[id].道具.数据[格子2] == nil then
		道具刷新(id)

		return
	elseif 格子3 ~= 0 and 玩家数据[id].道具.数据[格子3] == nil then
		道具刷新(id)

		return
	elseif 玩家数据[id].道具.数据[格子1].总类 ~= 2 or 玩家数据[id].道具.数据[格子2].总类 ~= 2 then
		常规提示(id, "只有装备才可以进行熔合")

		return
	elseif 玩家数据[id].道具.数据[格子1].级别限制 <= 59 or 玩家数据[id].道具.数据[格子2].级别限制 <= 59 or 玩家数据[id].道具.数据[格子1].级别限制 ~= 玩家数据[id].道具.数据[格子2].级别限制 then
		常规提示(id, "60级以上同级的两件装备才可以进行熔合")

		return
	elseif 玩家数据[id].道具.数据[格子1].分类 ~= 玩家数据[id].道具.数据[格子2].分类 then
		常规提示(id, "只有同部位的装备才可以进行熔合")

		return
	elseif 玩家数据[id].道具.数据[格子1].级别限制 >= 60 then
		if 玩家数据[id].道具.数据[格子1].加星 ~= 玩家数据[id].道具.数据[格子2].加星 then
			常规提示(id, "60级装备熔炼要求星级相同")

			return
		elseif 玩家数据[id].道具.数据[格子1].加星 ~= nil and 玩家数据[id].道具.数据[格子1].加星 >= 1 then
			常规提示(id, "该装备一件达到熔合次数上限")

			return
		end
	elseif 格子3 ~= 0 and 玩家数据[id].道具.数据[格子3].名称 ~= "融合石" then
		常规提示(id, "只有融合石才可以作为保障物品使用")

		return
	end

	local 等级 = 玩家数据[id].道具.数据[格子1].级别限制

	if 等级 >= 60 then
		local 检测 = {
			[1.0] = 0,
			[2.0] = 0
		}
		local 特效判断1 = {}

		if 玩家数据[id].道具.数据[格子1].特效 ~= nil then
			特效判断1 = 列表模式转换(玩家数据[id].道具.数据[格子1].特效)
		end

		if 特效判断1.无级别限制 ~= nil then
			检测[1] = 1
		end

		local 特效判断2 = {}

		if 玩家数据[id].道具.数据[格子2].特效 ~= nil then
			特效判断2 = 列表模式转换(玩家数据[id].道具.数据[格子2].特效)
		end

		if 特效判断2.无级别限制 ~= nil then
			检测[2] = 1
		end

		if 检测[1] == 0 or 检测[2] == 0 then
			常规提示(id, "60级以上装备熔合要求装备附带无级别特效")

			return
		end
	end

	local 星级 = 玩家数据[id].道具.数据[格子2].加星

	if 星级 == nil then
		星级 = 0
	end

	local 临时序列 = 0
	local 临时等级 = 0

	if 玩家数据[id].道具.数据[格子1].分类 == 3 then
		临时序列 = 取随机数(1, 18)
	elseif 玩家数据[id].道具.数据[格子1].分类 == 1 then
		临时序列 = 19
	elseif 玩家数据[id].道具.数据[格子1].分类 == 5 then
		临时序列 = 22
	elseif 玩家数据[id].道具.数据[格子1].分类 == 2 then
		临时序列 = 20
	elseif 玩家数据[id].道具.数据[格子1].分类 == 4 then
		临时序列 = 21
	elseif 玩家数据[id].道具.数据[格子1].分类 == 6 then
		临时序列 = 23
	end

	if 临时序列 == 0 then
		return
	end

	if 临时序列 <= 18 and 等级 <= 60 then
		临时等级 = 取随机数(6, 6)
	else
		临时等级 = 等级 / 10 + 1
	end

	local 临时类型 = self.打造物品[临时序列][临时等级]

	if type(临时类型) == "table" then
		临时类型 = 临时类型[取随机数(1, 2)]
	end

	local 成功率 = 100

	if 等级 >= 160 then
		成功率 = 100 - (星级 + 5) - 20
	else
		成功率 = 50
	end

	if ygsj() <= 成功率 then
		local 镶嵌等级1 = 0
		local 镶嵌等级2 = 0
		local 镶嵌类型 = {}

		if 玩家数据[id].道具.数据[格子1].锻炼等级 ~= nil then
			镶嵌等级1 = 玩家数据[id].道具.数据[格子1].锻炼等级
		end

		if 玩家数据[id].道具.数据[格子2].锻炼等级 ~= nil then
			镶嵌等级2 = 玩家数据[id].道具.数据[格子2].锻炼等级
		end

		if 镶嵌等级2 <= 镶嵌等级1 and 镶嵌等级1 ~= 0 then
			for i = 1, #玩家数据[id].道具.数据[格子1].镶嵌类型 do
				镶嵌类型[i] = 玩家数据[id].道具.数据[格子1].镶嵌类型[i]
			end
		elseif 镶嵌等级2 ~= 0 then
			for i = 1, #玩家数据[id].道具.数据[格子2].镶嵌类型 do
				镶嵌类型[i] = 玩家数据[id].道具.数据[格子2].镶嵌类型[i]
			end
		end

		if 等级 < 90 then
			任务处理类:设置熔合装备任务(id, 临时类型, 等级 + 10, 临时序列, 星级, 镶嵌类型, 1)
		else
			任务处理类:设置熔合装备任务(id, 临时类型, 等级, 临时序列, 星级, 镶嵌类型, 1)
		end

		玩家数据[id].道具.数据[格子1] = nil
		玩家数据[id].道具.数据[格子2] = nil
		玩家数据[id].角色.数据.道具[内容.序列] = nil
		玩家数据[id].角色.数据.道具[内容.序列1] = nil

		刷新道具行囊单格(id, "道具", 内容.序列, 格子1)
		刷新道具行囊单格(id, "道具", 内容.序列1, 格子2)
	elseif 格子3 ~= 0 then
		玩家数据[id].道具.数据[格子3] = nil
		玩家数据[id].角色.数据.道具[内容.序列2] = nil

		刷新道具行囊单格(id, "道具", 内容.序列2, 格子3)
		常规提示(id, "你使用了保护道具,本次合成失败,但不会损耗装备！")
	else
		玩家数据[id].道具.数据[格子1] = nil
		玩家数据[id].角色.数据.道具[内容.序列] = nil

		刷新道具行囊单格(id, "道具", 内容.序列, 格子1)
		常规提示(id, "哎呀火候没有掌握好,熔合失败了。你损失了1件装备")
	end
end

添加装备特效 = function(道具, 强化, 系统)
	local 打造特效 = 列表2加入到列表1({}, 全部特效)

	if 道具.分类 == 5 or 特效不限制部位 == 1 then
		table.insert(打造特效, "愤怒")
		table.insert(打造特效, "暴怒")

		if ygsj() < 5 then
			table.insert(打造特效, "超级愤怒")
			table.insert(打造特效, "超级暴怒")
		end
	end

	local 临时特效, aa = nil
	local 通用特效数量 = 0
	local 叠加特效概率 = 服务端参数.特效追加概率 + 0
	local 添加特效 = true
	local 矛盾 = {
		0,
		0
	}
	local 最大特效数量 = 打造最大特效数量 + 0
	local 当前特效数量 = 0

	if 系统 ~= nil then
		最大特效数量 = 系统装备最多特效数 + 0
	end

	if 强化 ~= nil then
		叠加特效概率 = 服务端参数.强化特效追加概率 + 0
	end

	while 添加特效 do
		local 重随 = false
		aa = ygsj(#打造特效)
		临时特效 = 打造特效[aa]

		if 通用特效1[临时特效] ~= nil then
			if 通用特效数量 < 通用特效上限 then
				通用特效数量 = 通用特效数量 + 1

				if 矛盾[1] > 0 then
					if 矛盾特效[临时特效] ~= nil then
						if 矛盾[1] < 矛盾特效[临时特效] then
							道具.特效[矛盾[2]] = 临时特效
						else
							重随 = true
						end
					else
						道具.特效[#道具.特效 + 1] = 临时特效
						当前特效数量 = 当前特效数量 + 1
					end
				else
					if 道具.特效 == nil then
						道具.特效 = {}
					end

					道具.特效[#道具.特效 + 1] = 临时特效
					当前特效数量 = 当前特效数量 + 1

					if 矛盾特效[临时特效] ~= nil then
						矛盾 = {
							矛盾特效[临时特效] + 0,
							通用特效数量
						}
					end
				end
			else
				重随 = true
			end
		else
			if 道具.新特效 == nil then
				道具.新特效 = {}
			end

			table.insert(道具.新特效, 临时特效)

			当前特效数量 = 当前特效数量 + 1
		end

		table.remove(打造特效, aa)

		if not 重随 then
			添加特效 = false

			if ygsj() <= math.min(叠加特效概率, 特效叠加概率限制) then
				添加特效 = true
			end
		end

		if #打造特效 == 0 or 最大特效数量 <= 当前特效数量 then
			添加特效 = false
		end
	end

	local 特效判断 = {}

	if 道具.特效 ~= nil then
		特效判断 = 列表模式转换(道具.特效)
	end

	取装备实际等级(道具, 特效判断)

	return 道具
end

function 装备处理类:添加强化打造装备(id, 任务id, 系统制造, 百炼, 制造者, 熟练度)
	local 道具 = 物品类()

	道具:置对象(任务数据[任务id].名称)

	道具.级别限制 = 任务数据[任务id].级别
	local dz = self:强化打造公式(id, 任务数据[任务id].级别, 任务数据[任务id].序列, 熟练度)

	if dz[1] ~= nil then
		道具.命中 = dz[1]
	end

	if dz[2] ~= nil then
		道具.伤害 = dz[2]
	end

	if dz[3] ~= nil then
		道具.防御 = dz[3]
	end

	if dz[4] ~= nil then
		道具.魔法 = dz[4]
	end

	if dz[5] ~= nil then
		道具.灵力 = dz[5]
	end

	if dz[6] ~= nil then
		道具.气血 = dz[6]
	end

	if dz[7] ~= nil then
		道具.敏捷 = dz[7]
	end

	if dz[8] ~= nil then
		道具.体质 = dz[8]
	end

	if dz[9] ~= nil then
		道具.力量 = dz[9]
	end

	if dz[10] ~= nil then
		道具.耐力 = dz[10]
	end

	if dz[11] ~= nil then
		道具.魔力 = dz[11]
	end

	if dz[12] ~= nil then
		道具 = 添加装备特效(道具, true)
	end

	if 祝福特效[id] == true then
		if 道具.新特效 == nil then
			道具.新特效 = {
				"祝福"
			}
		else
			table.insert(道具.新特效, "祝福")
		end

		祝福特效[id] = false

		常规提示(id, "#Y/恭喜你得到了一件#R/祝福#Y装备。")
	end

	if dz[13] ~= nil then
		道具.特技 = 通用特技[取随机数(1, #通用特技)]
	end

	if 系统制造 ~= nil then
		道具.制造者 = "系统制造"
	else
		道具.制造者 = (制造者 or 玩家数据[id].角色.数据.名称) .. "强化打造"
	end

	local 制造格子 = 玩家数据[id].道具:取新编号()
	玩家数据[id].道具.数据[制造格子] = 道具

	if 玩家数据[id].道具.数据[制造格子].级别限制 > 0 then
		玩家数据[id].道具.数据[制造格子].鉴定 = false
	end

	if 百炼 ~= nil and 玩家数据[id].角色.数据.百炼次数 ~= nil and math.floor(玩家数据[id].角色.数据.百炼次数) > 0 then
		玩家数据[id].道具.数据[制造格子].百炼效果 = 取百炼处理(道具.级别限制)
		玩家数据[id].角色.数据.百炼次数 = 玩家数据[id].角色.数据.百炼次数 - 1

		常规提示(id, "#Y/恭喜你打造了一件#R/百炼#Y装备。")
	end

	玩家数据[id].道具.数据[制造格子].超级五行 = 取超级五行处理(道具.级别限制, 10, 熟练度)
	玩家数据[id].道具.数据[制造格子].五行 = 玩家数据[id].道具.数据[制造格子].类型 or 取五行()

	if 玩家数据[id].道具.数据[制造格子].超级五行.类型 ~= nil then
		常规提示(id, "#Y/你得到了一件#R/超级五行#Y装备。")
	end

	玩家数据[id].道具.数据[制造格子].耐久 = 取随机数(600, 700)
	玩家数据[id].道具.数据[制造格子].识别码 = id .. "_" .. os.time() .. "_" .. 取随机数(1000, 9999999) .. "_" .. 随机序列
	随机序列 = 随机序列 + 1

	if 系统制造 ~= nil and 任务数据[任务id].类型 == 7758 and 任务数据[任务id].镶嵌等级 > 0 then
		玩家数据[id].道具.数据[制造格子].锻炼等级 = 任务数据[任务id].镶嵌等级
		玩家数据[id].道具.数据[制造格子].镶嵌宝石 = {}
		玩家数据[id].道具.数据[制造格子].镶嵌类型 = 任务数据[任务id].镶嵌类型
		local 镶嵌类型 = {
			{
				数量 = 1,
				类型 = 任务数据[任务id].镶嵌类型[1]
			}
		}

		for i = 2, 任务数据[任务id].镶嵌等级 do
			if 任务数据[任务id].镶嵌类型[i] == 镶嵌类型[1].类型 then
				镶嵌类型[1].数量 = 镶嵌类型[1].数量 + 1
			elseif 镶嵌类型[2] ~= nil then
				镶嵌类型[2].数量 = 镶嵌类型[2].数量 + 1
			else
				镶嵌类型[2] = {
					数量 = 1,
					类型 = 任务数据[任务id].镶嵌类型[i]
				}
			end
		end

		for i = 1, #镶嵌类型 do
			if 镶嵌类型[i].类型 == "太阳石" then
				if 玩家数据[id].道具.数据[制造格子].伤害 == nil then
					玩家数据[id].道具.数据[制造格子].伤害 = 0
				end

				玩家数据[id].道具.数据[制造格子].伤害 = math.floor(玩家数据[id].道具.数据[制造格子].伤害 + 镶嵌类型[i].数量 * 8)
			elseif 镶嵌类型[i].类型 == "红玛瑙" then
				if 玩家数据[id].道具.数据[制造格子].命中 == nil then
					玩家数据[id].道具.数据[制造格子].命中 = 0
				end

				玩家数据[id].道具.数据[制造格子].命中 = math.floor(玩家数据[id].道具.数据[制造格子].命中 + 镶嵌类型[i].数量 * 25)
			elseif 镶嵌类型[i].类型 == "月亮石" then
				if 玩家数据[id].道具.数据[制造格子].防御 == nil then
					玩家数据[id].道具.数据[制造格子].防御 = 0
				end

				玩家数据[id].道具.数据[制造格子].防御 = math.floor(玩家数据[id].道具.数据[制造格子].防御 + 镶嵌类型[i].数量 * 12)
			elseif 镶嵌类型[i].类型 == "黑宝石" then
				if 玩家数据[id].道具.数据[制造格子].速度 == nil then
					玩家数据[id].道具.数据[制造格子].速度 = 0
				end

				玩家数据[id].道具.数据[制造格子].速度 = math.floor(玩家数据[id].道具.数据[制造格子].速度 + 镶嵌类型[i].数量 * 8)
			elseif 镶嵌类型[i].类型 == "舍利子" then
				if 玩家数据[id].道具.数据[制造格子].灵力 == nil then
					玩家数据[id].道具.数据[制造格子].灵力 = 0
				end

				玩家数据[id].道具.数据[制造格子].灵力 = math.floor(玩家数据[id].道具.数据[制造格子].灵力 + 镶嵌类型[i].数量 * 6)
			elseif 镶嵌类型[i].类型 == "光芒石" then
				if 玩家数据[id].道具.数据[制造格子].气血 == nil then
					玩家数据[id].道具.数据[制造格子].气血 = 0
				end

				玩家数据[id].道具.数据[制造格子].气血 = math.floor(玩家数据[id].道具.数据[制造格子].气血 + 镶嵌类型[i].数量 * 40)
			elseif 镶嵌类型[i].类型 == "神秘石" then
				if 玩家数据[id].道具.数据[制造格子].躲避 == nil then
					玩家数据[id].道具.数据[制造格子].躲避 = 0
				end

				玩家数据[id].道具.数据[制造格子].躲避 = math.floor(玩家数据[id].道具.数据[制造格子].躲避 + 镶嵌类型[i].数量 * 20)
			end

			玩家数据[id].道具.数据[制造格子].镶嵌宝石[#玩家数据[id].道具.数据[制造格子].镶嵌宝石 + 1] = 镶嵌类型[i].类型
		end
	end

	if 获取道具模式[id] == nil then
		local gz = 玩家数据[id].角色:取超级行囊格子("装备")
		玩家数据[id].角色.数据.超级行囊.装备[gz] = 制造格子

		刷新超级行囊单格(id, 超级行囊类型列表1.装备, gz, 制造格子)
	else
		local gz = 玩家数据[id].角色:取道具格子()
		玩家数据[id].角色.数据.道具[玩家数据[id].角色:取道具格子()] = 制造格子

		刷新道具行囊单格(id, "道具", gz, 制造格子)
	end

	玩家数据[id].角色:取消任务(任务id)

	任务数据[任务id] = nil

	常规提示(id, "#Y/你得到了#R/" .. 玩家数据[id].道具.数据[制造格子].名称)
end

function 装备处理类:添加熔合装备属性(id, 任务id)
	local 道具 = 物品类()

	道具:置对象(任务数据[任务id].名称)

	道具.级别限制 = 任务数据[任务id].级别
	local 星级 = 任务数据[任务id].星级
	local 序列 = 任务数据[任务id].序列
	local 基础属性 = 1
	local a = 任务数据[任务id].级别
	local 系统制造 = 1

	if ygsj() <= 10 then
		系统制造 = 取随机数(2, 3)
	end

	星级 = 系统制造 + 星级

	if 序列 <= 18 then
		基础属性 = 5.1 + 星级 * 0.5
		道具.命中 = math.floor(a * 基础属性)
		道具.伤害 = math.floor(a * (基础属性 - 0.5))

		if 任务数据[任务id].指定.双加 == nil then
			local 范围 = {
				"力量",
				"敏捷",
				"体质",
				"耐力",
				"魔力"
			}

			if ygsj() <= 60 then
				local 目标 = 取随机数(1, #范围)
				道具[范围[目标]] = 取随机数(1, 60 + 星级 * 40)

				table.remove(范围, 目标)

				if ygsj() <= 30 then
					local 目标 = 取随机数(1, #范围)
					道具[范围[目标]] = 取随机数(1, 60 + 星级 * 40)
				end
			end
		else
			道具[任务数据[任务id].指定.双加[1]] = 取随机数(1, 60 + 星级 * 40)
			道具[任务数据[任务id].指定.双加[2]] = 取随机数(1, 60 + 星级 * 40)
		end
	elseif 序列 == 19 then
		基础属性 = 0.9 + 星级 * 0.1
		道具.防御 = math.floor(a * 基础属性)
		道具.魔法 = math.floor(a * (基础属性 + 0.5))
	elseif 序列 == 20 then
		基础属性 = 1.9 + 星级 * 0.1
		道具.灵力 = math.floor(a * 基础属性)
	elseif 序列 == 21 then
		基础属性 = 2.4 + 星级 * 0.1
		道具.防御 = math.floor(a * 基础属性)

		if 任务数据[任务id].指定.双加 == nil then
			local 范围 = {
				"力量",
				"敏捷",
				"体质",
				"耐力",
				"魔力"
			}

			if ygsj() <= 60 then
				local 目标 = 取随机数(1, #范围)
				道具[范围[目标]] = 取随机数(1, 60 + 星级 * 40)

				table.remove(范围, 目标)

				if ygsj() <= 30 then
					local 目标 = 取随机数(1, #范围)
					道具[范围[目标]] = 取随机数(1, 60 + 星级 * 40)
				end
			end
		else
			道具[任务数据[任务id].指定.双加[1]] = 取随机数(1, 60 + 星级 * 40)
			道具[任务数据[任务id].指定.双加[2]] = 取随机数(1, 60 + 星级 * 40)
		end
	elseif 序列 == 22 then
		基础属性 = 0.9 + 星级 * 0.1
		道具.防御 = math.floor(a * 基础属性)
		道具.气血 = math.floor(a * (基础属性 + 2))
	elseif 序列 == 23 then
		基础属性 = 0.9 + 星级 * 0.1
		道具.防御 = math.floor(a * 基础属性)
		道具.敏捷 = math.floor(a * (基础属性 - 0.2))
	end

	if ygsj() <= 10 then
		道具 = 添加装备特效(道具, nil, 1)
	end

	if ygsj() <= 5 then
		道具.特技 = 通用特技[取随机数(1, #通用特技)]
	end

	if 任务数据[任务id].指定.特技 ~= nil then
		道具.特技 = 任务数据[任务id].指定.特技
	end

	道具.制造者 = "系统制造"

	if 任务数据[任务id].指定.特效 ~= nil then
		local 特效判断 = {}

		if 道具.特效 ~= nil then
			特效判断 = 列表模式转换(道具.特效)
		end

		if 特效判断[任务数据[任务id].指定.特效] == nil then
			道具.特效[#道具.特效 + 1] = 任务数据[任务id].指定.特效
		end
	end

	local 制造格子 = 玩家数据[id].道具:取新编号()
	玩家数据[id].道具.数据[制造格子] = 道具
	玩家数据[id].道具.数据[制造格子].超级五行 = 取超级五行处理(道具.级别限制, 5)
	玩家数据[id].道具.数据[制造格子].五行 = 玩家数据[id].道具.数据[制造格子].类型 or 取五行()

	if 玩家数据[id].道具.数据[制造格子].超级五行.类型 ~= nil then
		常规提示(id, "#Y/你得到了一件#R/超级五行#Y装备。")
	end

	玩家数据[id].道具.数据[制造格子].耐久 = 取随机数(500, 700)
	玩家数据[id].道具.数据[制造格子].识别码 = id .. "_" .. os.time() .. "_" .. 取随机数(1000, 9999999) .. "_" .. 随机序列
	玩家数据[id].道具.数据[制造格子].加星 = 星级

	if 系统制造 >= 2 then
		发送数据(玩家数据[id].连接id, 1501, {
			名称 = "梦幻精灵",
			模型 = "普陀_接引仙女",
			对话 = "恭喜你的运气爆棚获得了一件 #G" .. 玩家数据[id].道具.数据[制造格子].加星 .. "星#R" .. 玩家数据[id].道具.数据[制造格子].名称
		})
	end

	if 任务数据[任务id].镶嵌等级 > 0 then
		玩家数据[id].道具.数据[制造格子].锻炼等级 = 任务数据[任务id].镶嵌等级
		玩家数据[id].道具.数据[制造格子].镶嵌宝石 = {}
		玩家数据[id].道具.数据[制造格子].镶嵌类型 = 任务数据[任务id].镶嵌类型
		local 镶嵌类型 = {
			{
				数量 = 1,
				类型 = 任务数据[任务id].镶嵌类型[1]
			}
		}

		for i = 2, 任务数据[任务id].镶嵌等级 do
			if 任务数据[任务id].镶嵌类型[i] == 镶嵌类型[1].类型 then
				镶嵌类型[1].数量 = 镶嵌类型[1].数量 + 1
			elseif 镶嵌类型[2] ~= nil then
				镶嵌类型[2].数量 = 镶嵌类型[2].数量 + 1
			else
				镶嵌类型[2] = {
					数量 = 1,
					类型 = 任务数据[任务id].镶嵌类型[i]
				}
			end
		end

		for i = 1, #镶嵌类型 do
			if 镶嵌类型[i].类型 == "太阳石" then
				if 玩家数据[id].道具.数据[制造格子].伤害 == nil then
					玩家数据[id].道具.数据[制造格子].伤害 = 0
				end

				玩家数据[id].道具.数据[制造格子].伤害 = math.floor(玩家数据[id].道具.数据[制造格子].伤害 + 镶嵌类型[i].数量 * 8)
			elseif 镶嵌类型[i].类型 == "红玛瑙" then
				if 玩家数据[id].道具.数据[制造格子].命中 == nil then
					玩家数据[id].道具.数据[制造格子].命中 = 0
				end

				玩家数据[id].道具.数据[制造格子].命中 = math.floor(玩家数据[id].道具.数据[制造格子].命中 + 镶嵌类型[i].数量 * 25)
			elseif 镶嵌类型[i].类型 == "月亮石" then
				if 玩家数据[id].道具.数据[制造格子].防御 == nil then
					玩家数据[id].道具.数据[制造格子].防御 = 0
				end

				玩家数据[id].道具.数据[制造格子].防御 = math.floor(玩家数据[id].道具.数据[制造格子].防御 + 镶嵌类型[i].数量 * 12)
			elseif 镶嵌类型[i].类型 == "黑宝石" then
				if 玩家数据[id].道具.数据[制造格子].速度 == nil then
					玩家数据[id].道具.数据[制造格子].速度 = 0
				end

				玩家数据[id].道具.数据[制造格子].速度 = 玩家数据[id].道具.数据[制造格子].速度 + 镶嵌类型[i].数量 * 8
			elseif 镶嵌类型[i].类型 == "舍利子" then
				if 玩家数据[id].道具.数据[制造格子].灵力 == nil then
					玩家数据[id].道具.数据[制造格子].灵力 = 0
				end

				玩家数据[id].道具.数据[制造格子].灵力 = math.floor(玩家数据[id].道具.数据[制造格子].灵力 + 镶嵌类型[i].数量 * 6)
			elseif 镶嵌类型[i].类型 == "光芒石" then
				if 玩家数据[id].道具.数据[制造格子].气血 == nil then
					玩家数据[id].道具.数据[制造格子].灵力 = 0
				end

				玩家数据[id].道具.数据[制造格子].气血 = math.floor(玩家数据[id].道具.数据[制造格子].气血 + 镶嵌类型[i].数量 * 40)
			elseif 镶嵌类型[i].类型 == "神秘石" then
				if 玩家数据[id].道具.数据[制造格子].躲避 == nil then
					玩家数据[id].道具.数据[制造格子].躲避 = 0
				end

				玩家数据[id].道具.数据[制造格子].躲避 = 玩家数据[id].道具.数据[制造格子].躲避 + 镶嵌类型[i].数量 * 20
			end

			玩家数据[id].道具.数据[制造格子].镶嵌宝石[#玩家数据[id].道具.数据[制造格子].镶嵌宝石 + 1] = 镶嵌类型[i].类型
		end
	end

	if 获取道具模式[id] == nil then
		local gz = 玩家数据[id].角色:取超级行囊格子("装备")
		玩家数据[id].角色.数据.超级行囊.装备[gz] = 制造格子

		刷新超级行囊单格(id, 超级行囊类型列表1.装备, gz, 制造格子)
	else
		local gz = 玩家数据[id].角色:取道具格子()
		玩家数据[id].角色.数据.道具[玩家数据[id].角色:取道具格子()] = 制造格子

		刷新道具行囊单格(id, "道具", gz, 制造格子)
	end

	玩家数据[id].角色:取消任务(任务id)

	任务数据[任务id] = nil

	常规提示(id, "#Y/你得到了#R/" .. 玩家数据[id].道具.数据[制造格子].名称)
end

function 装备处理类:给予星级装备(id, 星级)
	local 名称 = nil
	local 序列 = 0
	local 随机参数 = ygsj()

	if 随机参数 <= 10 then
		序列 = 取随机数(1, 18)
	elseif 随机参数 <= 20 then
		序列 = 19
	elseif 随机参数 <= 40 then
		序列 = 22
	elseif 随机参数 <= 60 then
		序列 = 20
	elseif 随机参数 <= 80 then
		序列 = 21
	else
		序列 = 23
	end

	if 序列 == 0 then
		return
	end

	名称 = self.打造物品[序列][17]

	if type(名称) == "table" then
		名称 = 名称[取随机数(1, 2)]
	end

	local 道具 = 物品类()

	道具:置对象(名称)

	道具.级别限制 = 160
	local 基础属性 = 1
	local a = 160

	if 序列 <= 18 then
		基础属性 = 5.1 + 星级 * 0.5
		道具.命中 = math.floor(a * 基础属性)
		道具.伤害 = math.floor(a * (基础属性 - 0.5))
		local 范围 = {
			"力量",
			"敏捷",
			"体质",
			"耐力",
			"魔力"
		}

		if ygsj() <= 60 then
			local 目标 = 取随机数(1, #范围)
			道具[范围[目标]] = 取随机数(1, 60 + 星级 * 40)

			table.remove(范围, 目标)

			if ygsj() <= 30 then
				local 目标 = 取随机数(1, #范围)
				道具[范围[目标]] = 取随机数(1, 60 + 星级 * 40)
			end
		end
	elseif 序列 == 19 then
		基础属性 = 0.9 + 星级 * 0.1
		道具.防御 = math.floor(a * 基础属性)
		道具.魔法 = math.floor(a * (基础属性 + 0.5))
	elseif 序列 == 20 then
		基础属性 = 1.9 + 星级 * 0.1
		道具.灵力 = math.floor(a * 基础属性)
	elseif 序列 == 21 then
		基础属性 = 2.4 + 星级 * 0.1
		道具.防御 = math.floor(a * 基础属性)
		local 范围 = {
			"力量",
			"敏捷",
			"体质",
			"耐力",
			"魔力"
		}

		if ygsj() <= 60 then
			local 目标 = 取随机数(1, #范围)
			道具[范围[目标]] = 取随机数(1, 60 + 星级 * 40)

			table.remove(范围, 目标)

			if ygsj() <= 30 then
				local 目标 = 取随机数(1, #范围)
				道具[范围[目标]] = 取随机数(1, 60 + 星级 * 40)
			end
		end
	elseif 序列 == 22 then
		基础属性 = 0.9 + 星级 * 0.1
		道具.防御 = math.floor(a * 基础属性)
		道具.气血 = math.floor(a * (基础属性 + 2))
	elseif 序列 == 23 then
		基础属性 = 0.9 + 星级 * 0.1
		道具.防御 = math.floor(a * 基础属性)
		道具.敏捷 = math.floor(a * (基础属性 - 0.2))
	end

	if ygsj() <= 10 then
		道具 = 添加装备特效(道具, nil, 1)
	end

	if ygsj() <= 5 then
		道具.特技 = 通用特技[取随机数(1, #通用特技)]
	end

	local 特效判断 = {}

	if 道具.特效 ~= nil then
		特效判断 = 列表模式转换(道具.特效)
	end

	if 特效判断.无级别限制 == nil then
		道具.特效 = 道具.特效 or {}
		道具.特效[#道具.特效 + 1] = "无级别限制"
	end

	local 制造格子 = 玩家数据[id].道具:取新编号()
	玩家数据[id].道具.数据[制造格子] = 道具
	玩家数据[id].道具.数据[制造格子].超级五行 = 取超级五行处理(道具.级别限制, 5)
	玩家数据[id].道具.数据[制造格子].五行 = 玩家数据[id].道具.数据[制造格子].类型 or 取五行()

	if 玩家数据[id].道具.数据[制造格子].超级五行.类型 ~= nil then
		常规提示(id, "#Y/你得到了一件#R/超级五行#Y装备。")
	end

	玩家数据[id].道具.数据[制造格子].耐久 = 取随机数(500, 700)
	玩家数据[id].道具.数据[制造格子].识别码 = id .. "_" .. os.time() .. "_" .. 取随机数(1000, 9999999) .. "_" .. 随机序列
	玩家数据[id].道具.数据[制造格子].加星 = 星级

	if 获取道具模式[id] == nil then
		local gz = 玩家数据[id].角色:取超级行囊格子("装备")
		玩家数据[id].角色.数据.超级行囊.装备[gz] = 制造格子

		刷新超级行囊单格(id, 超级行囊类型列表1.装备, gz, 制造格子)
	else
		local gz = 玩家数据[id].角色:取道具格子()
		玩家数据[id].角色.数据.道具[玩家数据[id].角色:取道具格子()] = 制造格子

		刷新道具行囊单格(id, "道具", gz, 制造格子)
	end

	常规提示(id, "#Y/你得到了#R/" .. 玩家数据[id].道具.数据[制造格子].名称)
end

function 装备处理类:生成指定召唤兽装备(id, 级别, 种类, 无级别)
	local 类型序列 = 0
	local 等级 = 级别 * 10 - 5
	local 名称 = 绑定等级物品()

	if 种类 == "护腕" then
		类型序列 = 24
	elseif 种类 == "项圈" then
		类型序列 = 25
	else
		类型序列 = 26
	end

	名称 = 名称[类型序列][级别]
	local 道具 = 物品类()

	道具:置对象(名称)

	道具.级别限制 = 等级
	道具.耐久 = 500
	道具.识别码 = id .. "_" .. os.time() .. "_" .. 取随机数(1000, 9999999) .. "_" .. 随机序列
	随机序列 = 随机序列 + 1
	local 灵气 = 取随机数(10, 100)

	if 种类 == "护腕" then
		道具.防御 = math.floor(取随机数(等级 * 0.35, 等级 * 0.7) + 取随机数(灵气 * 0.15, 灵气 * 0.25))

		if ygsj() <= 50 then
			道具.灵力 = math.floor(取随机数(等级 * 0.15 + 6.5, 等级 * 0.3 + 6.5) + 取随机数(灵气 * 0.07, 灵气 * 0.18))
		else
			道具.伤害 = math.floor(取随机数(等级 * 0.25 + 10, 等级 * 0.5 + 10) + 取随机数(灵气 * 0.1, 灵气 * 0.25))
		end
	elseif 种类 == "项圈" then
		道具.速度 = math.floor(取随机数(等级 * 0.1 + 5, 等级 * 0.25 + 10) + 取随机数(灵气 * 0.05, 灵气 * 0.15))

		if ygsj() <= 50 then
			道具.灵力 = math.floor(取随机数(等级 * 0.15 + 6.5, 等级 * 0.3 + 6.5) + 取随机数(灵气 * 0.07, 灵气 * 0.18))
		else
			道具.伤害 = math.floor(取随机数(等级 * 0.25 + 10, 等级 * 0.5 + 10) + 取随机数(灵气 * 0.1, 灵气 * 0.25))
		end
	else
		道具.防御 = math.floor(取随机数(等级 * 0.35, 等级 * 0.7) + 取随机数(灵气 * 0.15, 灵气 * 0.25))
		道具.气血 = math.floor(取随机数(等级 * 0.65 + 20, 等级 * 1.05 + 30) + 取随机数(灵气 * 0.45, 灵气 * 0.95))
	end

	local 特效 = {
		"无级别限制",
		"超级简易",
		"简易"
	}

	if 无级别 ~= nil and 无级别 == "无级别限制" then
		道具.特效 = 道具.特效 or {}
		道具.特效[#道具.特效 + 1] = "无级别限制"
	else
		道具.特效 = 道具.特效 or {}

		if ygsj() <= 4 then
			道具.特效[#道具.特效 + 1] = 特效[1]
		elseif ygsj() <= 4 then
			道具.特效[#道具.特效 + 1] = 特效[2]
		elseif ygsj() <= 4 then
			道具.特效[#道具.特效 + 1] = 特效[3]
		end
	end

	local 附加范围 = {
		"伤害",
		"灵力",
		"敏捷",
		"耐力",
		"体质",
		"力量",
		"魔力",
		"气血",
		"魔法"
	}

	for n = 1, 3 do
		if ygsj() <= 30 then
			local 类型 = 附加范围[取随机数(1, #附加范围)]

			if 道具[类型] == nil then
				if 类型 == "伤害" then
					道具[类型] = math.floor(取随机数(等级 * 0.15 + 10, 等级 * 0.4 + 10) + 取随机数(灵气 * 0.1, 灵气 * 0.25))
				elseif 类型 == "灵力" then
					道具[类型] = math.floor(取随机数(等级 * 0.15 + 10, 等级 * 0.4 + 10) + 取随机数(灵气 * 0.1, 灵气 * 0.25))
				elseif 类型 == "敏捷" or 类型 == "体质" or 类型 == "力量" or 类型 == "耐力" or 类型 == "魔力" then
					道具[类型] = math.floor(取随机数(等级 / 10 + 2, 等级 / 10 + 10) + 取随机数(灵气 / 20, 灵气 / 10))
				elseif 类型 == "速度" then
					道具[类型] = math.floor(取随机数(等级 * 0.1 + 5, 等级 * 0.25 + 10) + 取随机数(灵气 * 0.05, 灵气 * 0.15))
				elseif 类型 == "气血" then
					道具[类型] = math.floor(取随机数(等级 * 0.65 + 20, 等级 * 1.05 + 30) + 取随机数(灵气 * 0.45, 灵气 * 0.95))
				elseif 类型 == "魔法" then
					道具[类型] = math.floor(取随机数(等级 * 0.65 + 20, 等级 * 1.05 + 30) + 取随机数(灵气 * 0.45, 灵气 * 0.95))
				end
			end
		end
	end

	local 制造格子 = 玩家数据[id].道具:取新编号()
	玩家数据[id].道具.数据[制造格子] = 道具
	玩家数据[id].道具.数据[制造格子].超级五行 = 取超级五行处理(道具.级别限制, 5)
	玩家数据[id].道具.数据[制造格子].五行 = 玩家数据[id].道具.数据[制造格子].类型 or 取五行()

	if 玩家数据[id].道具.数据[制造格子].超级五行.类型 ~= nil then
		常规提示(id, "#Y/你得到了一件#R/超级五行#Y召唤兽装备。")
	end

	if 获取道具模式[id] == nil then
		local gz = 玩家数据[id].角色:取超级行囊格子("装备")
		玩家数据[id].角色.数据.超级行囊.装备[gz] = 制造格子

		刷新超级行囊单格(id, 超级行囊类型列表1.装备, gz, 制造格子)
	else
		local gz = 玩家数据[id].角色:取道具格子()
		玩家数据[id].角色.数据.道具[玩家数据[id].角色:取道具格子()] = 制造格子

		刷新道具行囊单格(id, "道具", gz, 制造格子)
	end

	玩家数据[id].角色:日志记录(format("生成装备：名称%s,级别%s,识别码%s", 道具.名称, 道具.级别限制, 道具.识别码))
	常规提示(id, "#Y/你得到了#R/" .. 玩家数据[id].道具.数据[制造格子].名称)

	return 制造格子
end

function 装备处理类:生成指定装备(id, 名称, 级别, 序列)
	local 道具 = 物品类()

	道具:置对象(名称)

	道具.级别限制 = 级别
	local dz = self:打造公式(id, 级别, 序列)

	if not 吊游定制 then
		for n = 1, 11 do
			if dz[n] ~= nil then
				dz[n] = math.floor(dz[n] * 取随机数(110, 120) / 100)
			end
		end
	end

	if dz[1] ~= nil then
		道具.命中 = dz[1]
	end

	if dz[2] ~= nil then
		道具.伤害 = dz[2]
	end

	if dz[3] ~= nil then
		道具.防御 = dz[3]
	end

	if dz[4] ~= nil then
		道具.魔法 = dz[4]
	end

	if dz[5] ~= nil then
		道具.灵力 = dz[5]
	end

	if dz[6] ~= nil then
		道具.气血 = dz[6]
	end

	if dz[7] ~= nil then
		道具.敏捷 = dz[7]
	end

	if dz[8] ~= nil then
		道具.体质 = dz[8]
	end

	if dz[9] ~= nil then
		道具.力量 = dz[9]
	end

	if dz[10] ~= nil then
		道具.耐力 = dz[10]
	end

	if dz[11] ~= nil then
		道具.魔力 = dz[11]
	end

	if dz[12] ~= nil then
		道具 = 添加装备特效(道具, nil, 1)
	end

	if 祝福特效[id] == true then
		if 道具.新特效 == nil then
			道具.新特效 = {
				"祝福"
			}
		else
			table.insert(道具.新特效, "祝福")
		end

		祝福特效[id] = false
	end

	if dz[13] ~= nil then
		道具.特技 = 通用特技[取随机数(1, #通用特技)]
	end

	道具.制造者 = "商城购买"
	local 制造格子 = 玩家数据[id].道具:取新编号()
	玩家数据[id].道具.数据[制造格子] = 道具
	玩家数据[id].道具.数据[制造格子].超级五行 = 取超级五行处理(道具.级别限制, 3)
	玩家数据[id].道具.数据[制造格子].五行 = 玩家数据[id].道具.数据[制造格子].类型 or 取五行()

	if 玩家数据[id].道具.数据[制造格子].超级五行.类型 ~= nil then
		常规提示(id, "#Y/你得到了一件#R/超级五行#Y装备。")
	end

	玩家数据[id].道具.数据[制造格子].耐久 = 取随机数(500, 700)
	玩家数据[id].道具.数据[制造格子].识别码 = id .. "_" .. os.time() .. "_" .. 取随机数(1000, 9999999) .. "_" .. 随机序列

	if 获取道具模式[id] == nil then
		local gz = 玩家数据[id].角色:取超级行囊格子("装备")
		玩家数据[id].角色.数据.超级行囊.装备[gz] = 制造格子

		刷新超级行囊单格(id, 超级行囊类型列表1.装备, gz, 制造格子)
	else
		local gz = 玩家数据[id].角色:取道具格子()
		玩家数据[id].角色.数据.道具[玩家数据[id].角色:取道具格子()] = 制造格子

		刷新道具行囊单格(id, "道具", gz, 制造格子)
	end

	玩家数据[id].角色:日志记录(format("生成装备：名称%s,级别%s,识别码%s", 道具.名称, 道具.级别限制, 玩家数据[id].道具.数据[制造格子].识别码))
	常规提示(id, "#Y/你得到了#R/" .. 玩家数据[id].道具.数据[制造格子].名称)

	return 制造格子
end

function 装备处理类:生成指定高级装备(id, 名称, 级别, 序列, 定制)
	local 道具 = 物品类()

	道具:置对象(名称)

	道具.级别限制 = 级别
	local dz = self:强化打造公式(id, 级别, 序列, nil, 定制)

	if not 吊游定制 then
		for n = 1, 11 do
			if dz[n] ~= nil then
				dz[n] = math.floor(dz[n] * 取随机数(100, 100) / 100)
			end
		end
	end

	if dz[1] ~= nil then
		道具.命中 = dz[1]
	end

	if dz[2] ~= nil then
		道具.伤害 = dz[2]
	end

	if dz[3] ~= nil then
		道具.防御 = dz[3]
	end

	if dz[4] ~= nil then
		道具.魔法 = dz[4]
	end

	if dz[5] ~= nil then
		道具.灵力 = dz[5]
	end

	if dz[6] ~= nil then
		道具.气血 = dz[6]
	end

	if dz[7] ~= nil then
		道具.敏捷 = dz[7]
	end

	if dz[8] ~= nil then
		道具.体质 = dz[8]
	end

	if dz[9] ~= nil then
		道具.力量 = dz[9]
	end

	if dz[10] ~= nil then
		道具.耐力 = dz[10]
	end

	if dz[11] ~= nil then
		道具.魔力 = dz[11]
	end

	if dz[12] ~= nil then
		道具 = 添加装备特效(道具, true, 1)
	end

	if 祝福特效[id] == true then
		if 道具.新特效 == nil then
			道具.新特效 = {
				"祝福"
			}
		else
			table.insert(道具.新特效, "祝福")
		end

		祝福特效[id] = false
	end

	if dz[13] ~= nil then
		道具.特技 = 通用特技[取随机数(1, #通用特技)]
	end

	道具.制造者 = "商城购买"
	local 制造格子 = 玩家数据[id].道具:取新编号()
	玩家数据[id].道具.数据[制造格子] = 道具
	玩家数据[id].道具.数据[制造格子].超级五行 = 取超级五行处理(道具.级别限制, 10, nil, 定制)
	玩家数据[id].道具.数据[制造格子].五行 = 玩家数据[id].道具.数据[制造格子].类型 or 取五行()

	if 玩家数据[id].道具.数据[制造格子].超级五行.类型 ~= nil then
		常规提示(id, "#Y/你得到了一件#R/超级五行#Y装备。")
	end

	玩家数据[id].道具.数据[制造格子].耐久 = 取随机数(500, 700)
	玩家数据[id].道具.数据[制造格子].识别码 = id .. "_" .. os.time() .. "_" .. 取随机数(1000, 9999999) .. "_" .. 随机序列

	if 获取道具模式[id] == nil then
		local gz = 玩家数据[id].角色:取超级行囊格子("装备")
		玩家数据[id].角色.数据.超级行囊.装备[gz] = 制造格子

		刷新超级行囊单格(id, 超级行囊类型列表1.装备, gz, 制造格子)
	else
		local gz = 玩家数据[id].角色:取道具格子()
		玩家数据[id].角色.数据.道具[玩家数据[id].角色:取道具格子()] = 制造格子

		刷新道具行囊单格(id, "道具", gz, 制造格子)
	end

	玩家数据[id].角色:日志记录(format("生成装备：名称%s,级别%s,识别码%s", 道具.名称, 道具.级别限制, 玩家数据[id].道具.数据[制造格子].识别码))
	常规提示(id, "#Y/你得到了#R/" .. 玩家数据[id].道具.数据[制造格子].名称)

	return 制造格子
end

function 装备处理类:生成指定GM定制装备(id, 名称, 级别, 序列, 定制)
	local 道具 = 物品类()

	道具:置对象(名称)

	道具.级别限制 = 级别
	local dz = {}

	if 级别 == 160 then
		dz = 幻化处理类:幻化公式(序列, 100, 定制)
	else
		dz = self:强化打造公式(id, 级别, 序列, nil, 定制)
	end

	if 定制 ~= nil then
		local 祝福加成 = 1

		if 定制.祝福 ~= nil then
			祝福加成 = 1.1
		end

		for n = 1, 11 do
			if dz[n] ~= nil then
				dz[n] = math.floor(dz[n] * 取随机数(108, 110) / 100 * 祝福加成)
			end
		end
	end

	if dz[1] ~= nil then
		道具.命中 = dz[1]
	end

	if dz[2] ~= nil then
		道具.伤害 = dz[2]
	end

	if dz[3] ~= nil then
		道具.防御 = dz[3]
	end

	if dz[4] ~= nil then
		道具.魔法 = dz[4]
	end

	if dz[5] ~= nil then
		道具.灵力 = dz[5]
	end

	if dz[6] ~= nil then
		道具.气血 = dz[6]
	end

	if dz[7] ~= nil then
		道具.敏捷 = dz[7]
	end

	if dz[8] ~= nil then
		道具.体质 = dz[8]
	end

	if dz[9] ~= nil then
		道具.力量 = dz[9]
	end

	if dz[10] ~= nil then
		道具.耐力 = dz[10]
	end

	if dz[11] ~= nil then
		道具.魔力 = dz[11]
	end

	道具.制造者 = "GM定制装备"
	道具.隐藏 = 1

	if 定制 ~= nil then
		if 定制.特技 ~= nil then
			道具.特技 = 定制.特技
		end

		if 定制.通用特效 ~= nil then
			道具.特效 = table.loadstring(table.tostring(定制.通用特效))
		end

		if 定制.新特效 ~= nil then
			道具.新特效 = table.loadstring(table.tostring(定制.新特效))
		end

		if 定制.百炼 ~= nil and #定制.百炼 > 0 then
			道具.百炼效果 = 取百炼处理(道具.级别限制, 100, 定制)
		end

		if 定制.套装类型 ~= nil and 定制.套装内容 ~= nil then
			道具.套装效果 = {
				定制.套装类型,
				定制.套装内容
			}
		end

		if 道具.伤害 ~= nil then
			道具.伤害 = math.ceil(道具.伤害 * 取随机数(服务端参数.专用属性下限 + (服务端参数.专用属性上限 - 服务端参数.专用属性下限) / 2, 服务端参数.专用属性上限) / 1000)
		end

		if 道具.灵力 ~= nil then
			道具.灵力 = math.ceil(道具.灵力 * 取随机数(服务端参数.专用属性下限 + (服务端参数.专用属性上限 - 服务端参数.专用属性下限) / 2, 服务端参数.专用属性上限) / 1000)
		end

		if 道具.防御 ~= nil then
			道具.防御 = math.ceil(道具.防御 * 取随机数(服务端参数.专用属性下限 + (服务端参数.专用属性上限 - 服务端参数.专用属性下限) / 2, 服务端参数.专用属性上限) / 1000)
		end

		if 道具.速度 ~= nil then
			道具.速度 = math.ceil(道具.速度 * 取随机数(服务端参数.专用属性下限 + (服务端参数.专用属性上限 - 服务端参数.专用属性下限) / 2, 服务端参数.专用属性上限) / 1000)
		end

		if 道具.气血 ~= nil then
			道具.气血 = math.ceil(道具.气血 * 取随机数(服务端参数.专用属性下限 + (服务端参数.专用属性上限 - 服务端参数.专用属性下限) / 2, 服务端参数.专用属性上限) / 1000)
		end

		if 道具.魔法 ~= nil then
			道具.魔法 = math.ceil(道具.魔法 * 取随机数(服务端参数.专用属性下限 + (服务端参数.专用属性上限 - 服务端参数.专用属性下限) / 2, 服务端参数.专用属性上限) / 1000)
		end

		if 道具.力量 ~= nil then
			道具.力量 = math.ceil(道具.力量 * 取随机数(服务端参数.专用属性下限 + (服务端参数.专用属性上限 - 服务端参数.专用属性下限) / 2, 服务端参数.专用属性上限) / 1000)
		end

		if 道具.魔力 ~= nil then
			道具.魔力 = math.ceil(道具.魔力 * 取随机数(服务端参数.专用属性下限 + (服务端参数.专用属性上限 - 服务端参数.专用属性下限) / 2, 服务端参数.专用属性上限) / 1000)
		end

		if 道具.耐力 ~= nil then
			道具.耐力 = math.ceil(道具.耐力 * 取随机数(服务端参数.专用属性下限 + (服务端参数.专用属性上限 - 服务端参数.专用属性下限) / 2, 服务端参数.专用属性上限) / 1000)
		end

		if 道具.体质 ~= nil then
			道具.体质 = math.ceil(道具.体质 * 取随机数(服务端参数.专用属性下限 + (服务端参数.专用属性上限 - 服务端参数.专用属性下限) / 2, 服务端参数.专用属性上限) / 1000)
		end

		if 道具.敏捷 ~= nil then
			道具.敏捷 = math.ceil(道具.敏捷 * 取随机数(服务端参数.专用属性下限 + (服务端参数.专用属性上限 - 服务端参数.专用属性下限) / 2, 服务端参数.专用属性上限) / 1000)
		end

		if 道具.躲避 ~= nil then
			道具.躲避 = math.ceil(道具.躲避 * 取随机数(服务端参数.专用属性下限 + (服务端参数.专用属性上限 - 服务端参数.专用属性下限) / 2, 服务端参数.专用属性上限) / 1000)
		end

		if 道具.命中 ~= nil then
			道具.命中 = math.ceil(道具.命中 * 取随机数(服务端参数.专用属性下限 + (服务端参数.专用属性上限 - 服务端参数.专用属性下限) / 2, 服务端参数.专用属性上限) / 1000)
		end

		道具.专用 = id
	end

	local 制造格子 = 玩家数据[id].道具:取新编号()
	玩家数据[id].道具.数据[制造格子] = 道具
	玩家数据[id].道具.数据[制造格子].超级五行 = 取超级五行处理(道具.级别限制, 100, nil, 定制)
	玩家数据[id].道具.数据[制造格子].五行 = 玩家数据[id].道具.数据[制造格子].类型 or 取五行()
	玩家数据[id].道具.数据[制造格子].耐久 = 1000
	玩家数据[id].道具.数据[制造格子].识别码 = id .. "_" .. os.time() .. "_" .. 取随机数(1000, 9999999) .. "_" .. 随机序列

	if 获取道具模式[id] == nil then
		local gz = 玩家数据[id].角色:取超级行囊格子("装备")
		玩家数据[id].角色.数据.超级行囊.装备[gz] = 制造格子

		刷新超级行囊单格(id, 超级行囊类型列表1.装备, gz, 制造格子)
	else
		local gz = 玩家数据[id].角色:取道具格子()
		玩家数据[id].角色.数据.道具[玩家数据[id].角色:取道具格子()] = 制造格子

		刷新道具行囊单格(id, "道具", gz, 制造格子)
	end

	去除角色定制数据(id)
	玩家数据[id].角色:日志记录(format("生成GM装备：名称%s,级别%s,识别码%s", 道具.名称, 道具.级别限制, 玩家数据[id].道具.数据[制造格子].识别码))
	常规提示(id, "#Y/你得到了#R/" .. 玩家数据[id].道具.数据[制造格子].名称)

	return 制造格子
end

function 装备处理类:打造公式(id, a, b, 熟练度, 定制)
	熟练度 = (熟练度 or 0) + 0
	local c = {}

	if a == nil or b == nil then
		return false
	end

	if 取随机数(1, 10000) <= (祝福特效概率 + 取熟练度加成(熟练度, "祝福")) * 100 then
		祝福特效[id] = true
		a = a + 10
	else
		祝福特效[id] = false
	end

	local 双加概率 = math.max(f函数.读配置(程序目录 .. "配置文件.ini", "主要配置", "打造双加概率") or 0, 10)
	local 双加概率1 = math.max(f函数.读配置(程序目录 .. "配置文件.ini", "主要配置", "打造单加概率") or 0, 20)
	双加概率 = (双加概率 + 取熟练度加成(熟练度, "双加")) * 100
	双加概率1 = (双加概率1 + 取熟练度加成(熟练度, "单加")) * 100

	if b < 19 then
		c[1] = 熟练度影响计算(a * 3.5 + 10, a * 4.5 + 25, 熟练度)
		c[2] = 熟练度影响计算(a * 3 + 10, a * 3.9 + 13, 熟练度)

		if 取随机数(1, 10000) <= 双加概率 then
			local sxs = {
				7,
				8,
				9,
				10,
				11
			}
			local sx1 = 取随机数(1, #sxs)
			local x1 = sxs[sx1]

			remove(sxs, sx1)

			sx1 = 取随机数(1, #sxs)
			local x2 = sxs[sx1]
			local 数值 = 取双加数值(a)
			c[x1] = 数值[1]
			c[x2] = 数值[2]
		elseif 取随机数(1, 10000) <= 双加概率1 then
			local sx = {
				取随机数(7, 11)
			}
			c[sx] = 取单加数值(a)
		end
	elseif b == 19 then
		c[3] = 熟练度影响计算(a * 0.5 + 5, a * 0.7 + 10, 熟练度)
		c[4] = 熟练度影响计算(a * 1 + 10, a * 1.3 + 20, 熟练度)

		if 装备全部位绿字 then
			if 取随机数(1, 10000) <= 双加概率 then
				local sxs = {
					7,
					8,
					9,
					10,
					11
				}
				local sx1 = 取随机数(1, #sxs)
				local x1 = sxs[sx1]

				remove(sxs, sx1)

				sx1 = 取随机数(1, #sxs)
				local x2 = sxs[sx1]
				local 数值 = 取双加数值(a)
				c[x1] = 数值[1]
				c[x2] = 数值[2]
			elseif 取随机数(1, 10000) <= 双加概率1 then
				local sx = {
					取随机数(7, 11)
				}
				c[sx] = 取单加数值(a)
			end
		end
	elseif b == 20 then
		c[5] = 熟练度影响计算(a * 1.21 + 3, a * 1.6 + 5, 熟练度)

		if 装备全部位绿字 then
			if 取随机数(1, 10000) <= 双加概率 then
				local sxs = {
					7,
					8,
					9,
					10,
					11
				}
				local sx1 = 取随机数(1, #sxs)
				local x1 = sxs[sx1]

				remove(sxs, sx1)

				sx1 = 取随机数(1, #sxs)
				local x2 = sxs[sx1]
				local 数值 = 取双加数值(a)
				c[x1] = 数值[1]
				c[x2] = 数值[2]
			elseif 取随机数(1, 10000) <= 双加概率1 then
				local sx = {
					取随机数(7, 11)
				}
				c[sx] = 取单加数值(a)
			end
		end
	elseif b == 21 then
		c[3] = 熟练度影响计算(a * 1.6 + 5, a * 2 + 10, 熟练度)

		if 取随机数(1, 10000) <= 双加概率 then
			local sxs = {
				7,
				8,
				9,
				10,
				11
			}
			local sx1 = 取随机数(1, #sxs)
			local x1 = sxs[sx1]

			remove(sxs, sx1)

			sx1 = 取随机数(1, #sxs)
			local x2 = sxs[sx1]
			local 数值 = 取双加数值(a)
			c[x1] = 数值[1]
			c[x2] = 数值[2]
		elseif 取随机数(1, 10000) <= 双加概率1 then
			local sx = {
				取随机数(7, 11)
			}
			c[sx] = 取单加数值(a)
		end
	elseif b == 22 then
		c[3] = 熟练度影响计算(a * 0.5 + 5, a * 0.7 + 10, 熟练度)
		c[6] = 熟练度影响计算(a * 2.2 + 10, a * 2.8 + 15, 熟练度)

		if 装备全部位绿字 then
			if 取随机数(1, 10000) <= 双加概率 then
				local sxs = {
					7,
					8,
					9,
					10,
					11
				}
				local sx1 = 取随机数(1, #sxs)
				local x1 = sxs[sx1]

				remove(sxs, sx1)

				sx1 = 取随机数(1, #sxs)
				local x2 = sxs[sx1]
				local 数值 = 取双加数值(a)
				c[x1] = 数值[1]
				c[x2] = 数值[2]
			elseif 取随机数(1, 10000) <= 双加概率1 then
				local sx = {
					取随机数(7, 11)
				}
				c[sx] = 取单加数值(a)
			end
		end
	elseif b == 23 then
		c[3] = 熟练度影响计算(a * 0.5 + 5, a * 0.7 + 10, 熟练度)
		c[7] = 熟练度影响计算(a * 0.3 + 6, a * 0.4 + 12, 熟练度)

		if 装备全部位绿字 then
			if 取随机数(1, 10000) <= 双加概率 then
				local sxs = {
					8,
					9,
					10,
					11
				}
				local sx1 = 取随机数(1, #sxs)
				local x1 = sxs[sx1]

				remove(sxs, sx1)

				sx1 = 取随机数(1, #sxs)
				local x2 = sxs[sx1]
				local 数值 = 取双加数值(a)
				c[x1] = 数值[1]
				c[x2] = 数值[2]
			elseif 取随机数(1, 10000) <= 双加概率1 then
				local sx = {
					取随机数(8, 11)
				}
				c[sx] = 取单加数值(a)
			end
		end
	end

	if 祝福特效[id] == true then
		a = a - 10
	end

	local tx = 取随机数(1, 10000)
	local txgl = f函数.读配置(程序目录 .. "配置文件.ini", "主要配置", "打造特效概率")

	if tonumber(txgl) == nil then
		txgl = 5
	end

	if tx <= (txgl + 取熟练度加成(熟练度, "特效")) * 100 then
		c[12] = 1
	end

	tx = 取随机数(1, 10000)
	txgl = f函数.读配置(程序目录 .. "配置文件.ini", "主要配置", "打造特技概率")

	if tonumber(txgl) == nil then
		txgl = 5
	end

	if tx <= (txgl + 取熟练度加成(熟练度, "特技")) * 100 then
		c[13] = 1
	end

	return c
end

function 装备处理类:强化打造公式(id, a, b, 熟练度, 定制)
	熟练度 = (熟练度 or 0) + 0
	local c = {}

	if a == nil or b == nil then
		return false
	end

	if 取随机数(1, 10000) <= (祝福特效概率 + 取熟练度加成(熟练度, "祝福")) * 100 or 定制 ~= nil and 定制.祝福 ~= nil then
		祝福特效[id] = true
		a = a + 10
	else
		祝福特效[id] = false
	end

	local 双加概率 = math.max(f函数.读配置(程序目录 .. "配置文件.ini", "主要配置", "强化打造双加概率") or 0, 30)
	local 双加概率1 = math.max(f函数.读配置(程序目录 .. "配置文件.ini", "主要配置", "强化打造单加概率") or 0, 80)
	双加概率 = (双加概率 + 取熟练度加成(熟练度, "双加")) * 100
	双加概率1 = (双加概率1 + 取熟练度加成(熟练度, "单加")) * 100

	if 定制 ~= nil then
		双加概率 = 10000
	end

	if b < 19 then
		c[1] = 熟练度影响计算(a * 3.7 + 25, a * 5 + 25, 熟练度)
		c[2] = 熟练度影响计算(a * 3.3 + 10, a * 4.2 + 14, 熟练度)

		if 取随机数(1, 10000) <= 双加概率 then
			local sxs = {
				7,
				8,
				9,
				10,
				11
			}
			local sx1 = 取随机数(1, #sxs)
			local x1 = sxs[sx1]

			remove(sxs, sx1)

			sx1 = 取随机数(1, #sxs)
			local x2 = sxs[sx1]
			local 数值 = 取双加数值(a, 1, 定制)
			c[x1] = 数值[1]
			c[x2] = 数值[2]
		elseif 取随机数(1, 10000) <= 双加概率1 then
			local sx = {
				取随机数(7, 11)
			}
			c[sx] = 取单加数值(a, 1, 定制)
		end
	elseif b == 19 then
		c[3] = 熟练度影响计算(a * 0.6 + 10, a * 0.8 + 10, 熟练度)
		c[4] = 熟练度影响计算(a * 1.3 + 15, a * 1.5 + 30, 熟练度)

		if 装备全部位绿字 then
			if 取随机数(1, 10000) <= 双加概率 then
				local sxs = {
					7,
					8,
					9,
					10,
					11
				}
				local sx1 = 取随机数(1, #sxs)
				local x1 = sxs[sx1]

				remove(sxs, sx1)

				sx1 = 取随机数(1, #sxs)
				local x2 = sxs[sx1]
				local 数值 = 取双加数值(a, 1, 定制)
				c[x1] = 数值[1]
				c[x2] = 数值[2]
			elseif 取随机数(1, 10000) <= 双加概率1 then
				local sx = {
					取随机数(7, 11)
				}
				c[sx] = 取单加数值(a, 1, 定制)
			end
		end
	elseif b == 20 then
		c[5] = 熟练度影响计算(a * 1.26 + 10, a * 1.63 + 15, 熟练度)

		if 装备全部位绿字 then
			if 取随机数(1, 10000) <= 双加概率 then
				local sxs = {
					7,
					8,
					9,
					10,
					11
				}
				local sx1 = 取随机数(1, #sxs)
				local x1 = sxs[sx1]

				remove(sxs, sx1)

				sx1 = 取随机数(1, #sxs)
				local x2 = sxs[sx1]
				local 数值 = 取双加数值(a, 1, 定制)
				c[x1] = 数值[1]
				c[x2] = 数值[2]
			elseif 取随机数(1, 10000) <= 双加概率1 then
				local sx = {
					取随机数(7, 11)
				}
				c[sx] = 取单加数值(a, 1, 定制)
			end
		end
	elseif b == 21 then
		c[3] = 熟练度影响计算(a * 1.68 + 15, a * 2.1 + 20, 熟练度)

		if 取随机数(1, 10000) <= 双加概率 then
			local sxs = {
				7,
				8,
				9,
				10,
				11
			}
			local sx1 = 取随机数(1, #sxs)
			local x1 = sxs[sx1]

			remove(sxs, sx1)

			sx1 = 取随机数(1, #sxs)
			local x2 = sxs[sx1]
			local 数值 = 取双加数值(a, 1, 定制)
			c[x1] = 数值[1]
			c[x2] = 数值[2]
		elseif 取随机数(1, 10000) <= 双加概率1 then
			local sx = {
				取随机数(7, 11)
			}
			c[sx] = 取单加数值(a, 1, 定制)
		end
	elseif b == 22 then
		c[3] = 熟练度影响计算(a * 0.6 + 10, a * 0.8 + 10, 熟练度)
		c[6] = 熟练度影响计算(a * 2.3 + 20, a * 3 + 30, 熟练度)

		if 装备全部位绿字 then
			if 取随机数(1, 10000) <= 双加概率 then
				local sxs = {
					7,
					8,
					9,
					10,
					11
				}
				local sx1 = 取随机数(1, #sxs)
				local x1 = sxs[sx1]

				remove(sxs, sx1)

				sx1 = 取随机数(1, #sxs)
				local x2 = sxs[sx1]
				local 数值 = 取双加数值(a, 1, 定制)
				c[x1] = 数值[1]
				c[x2] = 数值[2]
			elseif 取随机数(1, 10000) <= 双加概率1 then
				local sx = {
					取随机数(7, 11)
				}
				c[sx] = 取单加数值(a, 1, 定制)
			end
		end
	elseif b == 23 then
		c[3] = 熟练度影响计算(a * 0.6 + 10, a * 0.8 + 10, 熟练度)
		c[7] = 熟练度影响计算(a * 0.4 + 10, a * 0.5 + 15, 熟练度)

		if 装备全部位绿字 then
			if 取随机数(1, 10000) <= 双加概率 then
				local sxs = {
					8,
					9,
					10,
					11
				}
				local sx1 = 取随机数(1, #sxs)
				local x1 = sxs[sx1]

				remove(sxs, sx1)

				sx1 = 取随机数(1, #sxs)
				local x2 = sxs[sx1]
				local 数值 = 取双加数值(a, 1, 定制)
				c[x1] = 数值[1]
				c[x2] = 数值[2]
			elseif 取随机数(1, 10000) <= 双加概率1 then
				local sx = {
					取随机数(8, 11)
				}
				c[sx] = 取单加数值(a, 1, 定制)
			end
		end
	end

	if 祝福特效[id] == true then
		a = a - 10
	end

	local tx = 取随机数(1, 10000)
	local txgl = f函数.读配置(程序目录 .. "配置文件.ini", "主要配置", "强化打造特效概率")

	if tonumber(txgl) == nil then
		txgl = 10
	end

	if tx <= (txgl + 取熟练度加成(熟练度, "特效")) * 100 then
		c[12] = 1
	end

	tx = 取随机数(1, 10000)
	txgl = f函数.读配置(程序目录 .. "配置文件.ini", "主要配置", "强化打造特技概率")

	if tonumber(txgl) == nil then
		txgl = 10
	end

	if tx <= (txgl + 取熟练度加成(熟练度, "特技")) * 100 then
		c[13] = 1
	end

	return c
end

function 装备处理类:指定等级物品(lv, id)
	local wps = self.打造物品[id]
	local 取随机数 = 引擎.取随机整数
	local ids = floor(lv / 10 + 1)

	if id <= 18 and lv >= 90 and lv <= 140 then
		if ids <= 12 then
			ids = 取随机数(10, 12)
		else
			ids = 取随机数(13, 15)
		end
	end

	wps = wps[ids]

	if type(wps) == "table" then
		wps = wps[取随机数(1, 2)]
	end

	return wps
end

function 装备处理类:强化打造()
end

function 装备处理类:取可以镶嵌(zb, bs, zbzl)
	if zb == 1 and (bs == 2 or bs == 3 or bs == 5) then
		return true
	elseif zb == 2 and bs == 4 then
		return true
	elseif (zb == 3 or zb == 4 and zbzl == 911) and (bs == 3 or bs == 5 or bs == 7 or bs == 1001) then
		return true
	elseif zb == 4 and zbzl ~= 911 and (bs == 1 or bs == 2 or bs == 4 or bs == 1001) then
		return true
	elseif zb == 5 and (bs == 1 or bs == 6 or bs == 7) then
		return true
	elseif zb == 6 and (bs == 6 or bs == 7) then
		return true
	end
end

function 装备处理类:取宝石合成几率(id, 级别)
	if 级别 <= 玩家数据[id].角色:取剧情技能等级("宝石工艺") * 2 - 4 then
		return true
	end

	local 初始几率 = 50

	if 级别 <= 20 then
		初始几率 = 100
	elseif 初始几率 <= 25 then
		初始几率 = 80
	end

	if 取随机数(1, 10000) > 初始几率 * 100 then
		return false
	else
		return true
	end
end

function 装备处理类:更新(dt)
end

function 装备处理类:显示(x, y)
end

return 装备处理类
